diff --git a/.gitattributes b/.gitattributes
index 93167fa5125e5a3766052d4646ef62b5f598a017..a40ab5926adcac073e5c694f72eca864d61e1d0a 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -3469,3 +3469,17 @@ physworld_p1_20261018/envs/p1/lib/python3.11/lib2to3/tests/data/__pycache__/infi
 physworld_p1_20261018/envs/p1/lib/python3.11/pydoc_data/__pycache__/topics.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/__pycache__/Image.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
 physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/__pycache__/TiffImagePlugin.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/core.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/eglRenderer.cpython-311-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/hf_xet.abi3.so filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
+physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc filter=lfs diff=lfs merge=lfs -text
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..618b27764a30d85090a857bfd185aa5dec8f3f91
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.cpython-311-x86_64-linux-gnu.so differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_avif.pyi
@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_binary.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_binary.py
new file mode 100644
index 0000000000000000000000000000000000000000..5b0399fbc46dc3a18857dfa720c96a1618d17e7e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_binary.py
@@ -0,0 +1,115 @@
+#
+# The Python Imaging Library.
+# $Id$
+#
+# Binary input/output support routines.
+#
+# Copyright (c) 1997-2003 by Secret Labs AB
+# Copyright (c) 1995-2003 by Fredrik Lundh
+# Copyright (c) 2012 by Brian Crowell
+#
+# See the README file for information on usage and redistribution.
+#
+
+
+"""Binary input/output support routines."""
+
+from __future__ import annotations
+
+__lazy_modules__ = {"struct"}
+
+from struct import unpack_from
+
+
+def i8(c: bytes) -> int:
+    return c[0]
+
+
+def o8(i: int) -> bytes:
+    return (i & 255).to_bytes()
+
+
+# Input, le = little endian, be = big endian
+def i16le(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 2-bytes (16 bits) string to an unsigned integer.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from("<H", c, o)[0]
+
+
+def si16le(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 2-bytes (16 bits) string to a signed integer.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from("<h", c, o)[0]
+
+
+def si16be(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 2-bytes (16 bits) string to a signed integer, big endian.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from(">h", c, o)[0]
+
+
+def i32le(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 4-bytes (32 bits) string to an unsigned integer.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from("<I", c, o)[0]
+
+
+def si32le(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 4-bytes (32 bits) string to a signed integer.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from("<i", c, o)[0]
+
+
+def si32be(c: bytes, o: int = 0) -> int:
+    """
+    Converts a 4-bytes (32 bits) string to a signed integer, big endian.
+
+    :param c: string containing bytes to convert
+    :param o: offset of bytes to convert in string
+    """
+    return unpack_from(">i", c, o)[0]
+
+
+def i16be(c: bytes, o: int = 0) -> int:
+    return unpack_from(">H", c, o)[0]
+
+
+def i32be(c: bytes, o: int = 0) -> int:
+    return unpack_from(">I", c, o)[0]
+
+
+# Output, le = little endian, be = big endian
+def o16le(i: int) -> bytes:
+    return i.to_bytes(2, "little")
+
+
+def o32le(i: int) -> bytes:
+    return i.to_bytes(4, "little")
+
+
+def o16be(i: int) -> bytes:
+    return i.to_bytes(2, "big")
+
+
+def o32be(i: int) -> bytes:
+    return i.to_bytes(4, "big")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_deprecate.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_deprecate.py
new file mode 100644
index 0000000000000000000000000000000000000000..f28afffd32d8977bbb8989885c21844b23302333
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_deprecate.py
@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+__lazy_modules__ = {"warnings"}
+
+import warnings
+
+from . import __version__
+
+
+def deprecate(
+    deprecated: str,
+    when: int | None,
+    replacement: str | None = None,
+    *,
+    action: str | None = None,
+    plural: bool = False,
+    stacklevel: int = 3,
+) -> None:
+    """
+    Deprecations helper.
+
+    :param deprecated: Name of thing to be deprecated.
+    :param when: Pillow major version to be removed in.
+    :param replacement: Name of replacement.
+    :param action: Instead of "replacement", give a custom call to action
+        e.g. "Upgrade to new thing".
+    :param plural: if the deprecated thing is plural, needing "are" instead of "is".
+
+    Usually of the form:
+
+        "[deprecated] is deprecated and will be removed in Pillow [when] (yyyy-mm-dd).
+        Use [replacement] instead."
+
+    You can leave out the replacement sentence:
+
+        "[deprecated] is deprecated and will be removed in Pillow [when] (yyyy-mm-dd)"
+
+    Or with another call to action:
+
+        "[deprecated] is deprecated and will be removed in Pillow [when] (yyyy-mm-dd).
+        [action]."
+    """
+
+    is_ = "are" if plural else "is"
+
+    if when is None:
+        removed = "a future version"
+    elif when <= int(__version__.split(".")[0]):
+        msg = f"{deprecated} {is_} deprecated and should be removed."
+        raise RuntimeError(msg)
+    elif when == 14:
+        removed = "Pillow 14 (2027-10-15)"
+    elif when == 15:
+        removed = "Pillow 15 (2028-10-15)"
+    else:
+        msg = f"Unknown removal version: {when}. Update {__name__}?"
+        raise ValueError(msg)
+
+    if replacement and action:
+        msg = "Use only one of 'replacement' and 'action'"
+        raise ValueError(msg)
+
+    if replacement:
+        action = f". Use {replacement} instead."
+    elif action:
+        action = f". {action.rstrip('.')}."
+    else:
+        action = ""
+
+    warnings.warn(
+        f"{deprecated} {is_} deprecated and will be removed in {removed}{action}",
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..0c1bf29a32b543ebeeb1de5996b388f2167d0e5a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7aefe0e37d27e2d1446bd74003f307245e70099f8610258acff1a18e8778b2f6
+size 3461569
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..81028a5960ae34ec74285c456d9b691dc6a67a93
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imaging.pyi
@@ -0,0 +1,31 @@
+from typing import Any
+
+class ImagingCore:
+    def __getitem__(self, index: int) -> float | tuple[int, ...] | None: ...
+    def __getattr__(self, name: str) -> Any: ...
+
+class ImagingFont:
+    def __getattr__(self, name: str) -> Any: ...
+
+class ImagingDraw:
+    def __getattr__(self, name: str) -> Any: ...
+
+class PixelAccess:
+    def __getitem__(self, xy: tuple[int, int]) -> float | tuple[int, ...]: ...
+    def __setitem__(
+        self, xy: tuple[int, int], color: float | tuple[int, ...]
+    ) -> None: ...
+
+class ImagingDecoder:
+    def __getattr__(self, name: str) -> Any: ...
+
+class ImagingEncoder:
+    def __getattr__(self, name: str) -> Any: ...
+
+class _Outline:
+    def close(self) -> None: ...
+    def __getattr__(self, name: str) -> Any: ...
+
+def font(image: ImagingCore, glyphdata: bytes) -> ImagingFont: ...
+def outline() -> _Outline: ...
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..79b5711fb943ec3021d5e0151ed41baa58d29d27
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2b0baa6a6a7a8ef3e49270fd4509b69a559dd671160cc15b84b0c83e3dde9b23
+size 163729
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..4fc0d60ab79375281abb6d53d9d707cf18f09815
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingcms.pyi
@@ -0,0 +1,143 @@
+import datetime
+import sys
+from typing import Literal, SupportsFloat, TypeAlias, TypedDict
+
+from ._typing import CapsuleType
+
+littlecms_version: str | None
+
+_Tuple3f: TypeAlias = tuple[float, float, float]
+_Tuple2x3f: TypeAlias = tuple[_Tuple3f, _Tuple3f]
+_Tuple3x3f: TypeAlias = tuple[_Tuple3f, _Tuple3f, _Tuple3f]
+
+class _IccMeasurementCondition(TypedDict):
+    observer: int
+    backing: _Tuple3f
+    geo: str
+    flare: float
+    illuminant_type: str
+
+class _IccViewingCondition(TypedDict):
+    illuminant: _Tuple3f
+    surround: _Tuple3f
+    illuminant_type: str
+
+class CmsProfile:
+    @property
+    def rendering_intent(self) -> int: ...
+    @property
+    def creation_date(self) -> datetime.datetime | None: ...
+    @property
+    def copyright(self) -> str | None: ...
+    @property
+    def target(self) -> str | None: ...
+    @property
+    def manufacturer(self) -> str | None: ...
+    @property
+    def model(self) -> str | None: ...
+    @property
+    def profile_description(self) -> str | None: ...
+    @property
+    def screening_description(self) -> str | None: ...
+    @property
+    def viewing_condition(self) -> str | None: ...
+    @property
+    def version(self) -> float: ...
+    @property
+    def icc_version(self) -> int: ...
+    @property
+    def attributes(self) -> int: ...
+    @property
+    def header_flags(self) -> int: ...
+    @property
+    def header_manufacturer(self) -> str: ...
+    @property
+    def header_model(self) -> str: ...
+    @property
+    def device_class(self) -> str: ...
+    @property
+    def connection_space(self) -> str: ...
+    @property
+    def xcolor_space(self) -> str: ...
+    @property
+    def profile_id(self) -> bytes: ...
+    @property
+    def is_matrix_shaper(self) -> bool: ...
+    @property
+    def technology(self) -> str | None: ...
+    @property
+    def colorimetric_intent(self) -> str | None: ...
+    @property
+    def perceptual_rendering_intent_gamut(self) -> str | None: ...
+    @property
+    def saturation_rendering_intent_gamut(self) -> str | None: ...
+    @property
+    def red_colorant(self) -> _Tuple2x3f | None: ...
+    @property
+    def green_colorant(self) -> _Tuple2x3f | None: ...
+    @property
+    def blue_colorant(self) -> _Tuple2x3f | None: ...
+    @property
+    def red_primary(self) -> _Tuple2x3f | None: ...
+    @property
+    def green_primary(self) -> _Tuple2x3f | None: ...
+    @property
+    def blue_primary(self) -> _Tuple2x3f | None: ...
+    @property
+    def media_white_point_temperature(self) -> float | None: ...
+    @property
+    def media_white_point(self) -> _Tuple2x3f | None: ...
+    @property
+    def media_black_point(self) -> _Tuple2x3f | None: ...
+    @property
+    def luminance(self) -> _Tuple2x3f | None: ...
+    @property
+    def chromatic_adaptation(self) -> tuple[_Tuple3x3f, _Tuple3x3f] | None: ...
+    @property
+    def chromaticity(self) -> _Tuple3x3f | None: ...
+    @property
+    def colorant_table(self) -> list[str] | None: ...
+    @property
+    def colorant_table_out(self) -> list[str] | None: ...
+    @property
+    def intent_supported(self) -> dict[int, tuple[bool, bool, bool]] | None: ...
+    @property
+    def clut(self) -> dict[int, tuple[bool, bool, bool]] | None: ...
+    @property
+    def icc_measurement_condition(self) -> _IccMeasurementCondition | None: ...
+    @property
+    def icc_viewing_condition(self) -> _IccViewingCondition | None: ...
+    def is_intent_supported(self, intent: int, direction: int, /) -> int: ...
+
+class CmsTransform:
+    def apply(self, id_in: CapsuleType, id_out: CapsuleType) -> int: ...
+
+def profile_open(profile: str, /) -> CmsProfile: ...
+def profile_frombytes(profile: bytes, /) -> CmsProfile: ...
+def profile_tobytes(profile: CmsProfile, /) -> bytes: ...
+def buildTransform(
+    input_profile: CmsProfile,
+    output_profile: CmsProfile,
+    in_mode: str,
+    out_mode: str,
+    rendering_intent: int = 0,
+    cms_flags: int = 0,
+    /,
+) -> CmsTransform: ...
+def buildProofTransform(
+    input_profile: CmsProfile,
+    output_profile: CmsProfile,
+    proof_profile: CmsProfile,
+    in_mode: str,
+    out_mode: str,
+    rendering_intent: int = 0,
+    proof_intent: int = 0,
+    cms_flags: int = 0,
+    /,
+) -> CmsTransform: ...
+def createProfile(
+    color_space: Literal["LAB", "XYZ", "sRGB"], color_temp: SupportsFloat = 0.0, /
+) -> CmsProfile: ...
+
+if sys.platform == "win32":
+    def get_display_profile_win32(handle: int = 0, is_dc: int = 0, /) -> str | None: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..27aaafd0cef250a0df4b4e8ee2d1b91ba210245e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:104f1199ccb1a6e501edcfa229f7209cc970a781bf00a9fb78d95264cd38c64f
+size 345281
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..2136810ba6a95e0c025a71cf7fbbc5b60490fed7
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingft.pyi
@@ -0,0 +1,70 @@
+from collections.abc import Callable
+from typing import Any
+
+from . import ImageFont, _imaging
+
+class Font:
+    @property
+    def family(self) -> str | None: ...
+    @property
+    def style(self) -> str | None: ...
+    @property
+    def ascent(self) -> int: ...
+    @property
+    def descent(self) -> int: ...
+    @property
+    def height(self) -> int: ...
+    @property
+    def x_ppem(self) -> int: ...
+    @property
+    def y_ppem(self) -> int: ...
+    @property
+    def glyphs(self) -> int: ...
+    def render(
+        self,
+        string: str | bytes,
+        fill: Callable[[int, int], _imaging.ImagingCore],
+        mode: str,
+        dir: str | None,
+        features: list[str] | None,
+        lang: str | None,
+        stroke_width: float,
+        stroke_filled: bool,
+        anchor: str | None,
+        foreground_ink_long: int,
+        start: tuple[float, float],
+        /,
+    ) -> tuple[_imaging.ImagingCore, tuple[int, int]]: ...
+    def getsize(
+        self,
+        string: str | bytes | bytearray,
+        mode: str,
+        dir: str | None,
+        features: list[str] | None,
+        lang: str | None,
+        anchor: str | None,
+        /,
+    ) -> tuple[tuple[int, int], tuple[int, int]]: ...
+    def getlength(
+        self,
+        string: str | bytes,
+        mode: str,
+        dir: str | None,
+        features: list[str] | None,
+        lang: str | None,
+        /,
+    ) -> float: ...
+    def getvarnames(self) -> list[bytes]: ...
+    def getvaraxes(self) -> list[ImageFont.Axis]: ...
+    def setvarname(self, instance_index: int, /) -> None: ...
+    def setvaraxes(self, axes: list[float], /) -> None: ...
+
+def getfont(
+    filename: str | bytes,
+    size: float,
+    index: int,
+    encoding: str,
+    font_bytes: bytes,
+    layout_engine: int,
+) -> Font: ...
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..0cdc965c3646eb297d33733e803a09e107f0b9a5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:96ae71e30d176fbf291607d873add7628b7de4a58f57358489a9036b5ff20e11
+size 137496
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmath.pyi
@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..61885a9a2f40adc1ac950004ac2da7db3de2c8c7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.cpython-311-x86_64-linux-gnu.so differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingmorph.pyi
@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..f57e98bde72a1fdcd95e088b8d479d61dc10efc2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.cpython-311-x86_64-linux-gnu.so differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_imagingtk.pyi
@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_tkinter_finder.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_tkinter_finder.py
new file mode 100644
index 0000000000000000000000000000000000000000..9c0143003a7320dd475cfcd168168b82e4f64964
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_tkinter_finder.py
@@ -0,0 +1,20 @@
+"""Find compiled module linking to Tcl / Tk libraries"""
+
+from __future__ import annotations
+
+import sys
+import tkinter
+
+tk = getattr(tkinter, "_tkinter")
+
+try:
+    if hasattr(sys, "pypy_find_executable"):
+        TKINTER_LIB = tk.tklib_cffi.__file__
+    else:
+        TKINTER_LIB = tk.__file__
+except AttributeError:
+    # _tkinter may be compiled directly into Python, in which case __file__ is
+    # not available. load_tkinter_funcs will check the binary first in any case.
+    TKINTER_LIB = None
+
+tk_version = str(tkinter.TkVersion)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_typing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_typing.py
new file mode 100644
index 0000000000000000000000000000000000000000..7b60d45682fc6045595eae6a59c46b5651475129
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_typing.py
@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+__lazy_modules__ = {"numbers", "types"}
+
+import os
+import sys
+from collections.abc import Sequence
+from numbers import _IntegralLike as IntegralLike
+from typing import Any, Protocol, TypeVar
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    try:
+        import numpy.typing as npt
+
+        NumpyArray = npt.NDArray[Any]
+    except ImportError:
+        pass
+
+if sys.version_info >= (3, 13):
+    from types import CapsuleType
+else:
+    CapsuleType = object
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    Buffer = Any
+
+
+_Ink = float | tuple[int, ...] | str
+
+Coords = Sequence[float] | Sequence[Sequence[float]]
+
+
+_T_co = TypeVar("_T_co", covariant=True)
+
+
+class SupportsRead(Protocol[_T_co]):
+    def read(self, length: int = ..., /) -> _T_co: ...
+
+
+StrOrBytesPath = str | bytes | os.PathLike[str] | os.PathLike[bytes]
+
+
+__all__ = ["Buffer", "IntegralLike", "StrOrBytesPath", "SupportsRead"]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..b1fa6a0f39ed2847723f20fc81462adc9245d970
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_util.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+import os
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Any, NoReturn, TypeGuard
+
+    from ._typing import StrOrBytesPath
+
+
+def is_path(f: Any) -> TypeGuard[StrOrBytesPath]:
+    return isinstance(f, (bytes, str, os.PathLike))
+
+
+class DeferredError:
+    def __init__(self, ex: BaseException):
+        self.ex = ex
+
+    def __getattr__(self, elt: str) -> NoReturn:
+        raise self.ex
+
+    @staticmethod
+    def new(ex: BaseException) -> Any:
+        """
+        Creates an object that raises the wrapped exception ``ex`` when used,
+        and casts it to :py:obj:`~typing.Any` type.
+        """
+        return DeferredError(ex)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_version.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c358640935273e55b39c88638970c35b22a49da
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_version.py
@@ -0,0 +1,4 @@
+# Master version for Pillow
+from __future__ import annotations
+
+__version__ = "13.0.0"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..2273d78f39cb37157b2456c60d6ca4524656515a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f66802dd349cabf0ba85c58a246fe3e1afcf36ca407e200a0271f47737592b97
+size 110617
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.pyi b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.pyi
new file mode 100644
index 0000000000000000000000000000000000000000..e27843e5338213713e26973127c738c14313ff98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/_webp.pyi
@@ -0,0 +1,3 @@
+from typing import Any
+
+def __getattr__(name: str) -> Any: ...
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/features.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/features.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7cf7318eaa2926b979c8d40dc355b65add4b77f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/features.py
@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+__lazy_modules__ = {"collections", "warnings"}
+
+import collections
+import os
+import sys
+import warnings
+
+import PIL
+
+from . import Image
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import IO
+modules = {
+    "pil": ("PIL._imaging", "PILLOW_VERSION"),
+    "tkinter": ("PIL._tkinter_finder", "tk_version"),
+    "freetype2": ("PIL._imagingft", "freetype2_version"),
+    "littlecms2": ("PIL._imagingcms", "littlecms_version"),
+    "webp": ("PIL._webp", "webpdecoder_version"),
+    "avif": ("PIL._avif", "libavif_version"),
+}
+
+
+def check_module(feature: str) -> bool:
+    """
+    Checks if a module is available.
+
+    :param feature: The module to check for.
+    :returns: ``True`` if available, ``False`` otherwise.
+    :raises ValueError: If the module is not defined in this version of Pillow.
+    """
+    if feature not in modules:
+        msg = f"Unknown module {feature}"
+        raise ValueError(msg)
+
+    module, ver = modules[feature]
+
+    try:
+        __import__(module)
+        return True
+    except ModuleNotFoundError:
+        return False
+    except ImportError as ex:
+        warnings.warn(str(ex))
+        return False
+
+
+def version_module(feature: str) -> str | None:
+    """
+    :param feature: The module to check for.
+    :returns:
+        The loaded version number as a string, or ``None`` if unknown or not available.
+    :raises ValueError: If the module is not defined in this version of Pillow.
+    """
+    if not check_module(feature):
+        return None
+
+    module, ver = modules[feature]
+
+    return getattr(__import__(module, fromlist=[ver]), ver)
+
+
+def get_supported_modules() -> list[str]:
+    """
+    :returns: A list of all supported modules.
+    """
+    return [f for f in modules if check_module(f)]
+
+
+codecs = {
+    "jpg": ("jpeg", "jpeglib"),
+    "jpg_2000": ("jpeg2k", "jp2klib"),
+    "zlib": ("zip", "zlib"),
+    "libtiff": ("libtiff", "libtiff"),
+}
+
+
+def check_codec(feature: str) -> bool:
+    """
+    Checks if a codec is available.
+
+    :param feature: The codec to check for.
+    :returns: ``True`` if available, ``False`` otherwise.
+    :raises ValueError: If the codec is not defined in this version of Pillow.
+    """
+    if feature not in codecs:
+        msg = f"Unknown codec {feature}"
+        raise ValueError(msg)
+
+    codec, lib = codecs[feature]
+
+    return f"{codec}_encoder" in dir(Image.core)
+
+
+def version_codec(feature: str) -> str | None:
+    """
+    :param feature: The codec to check for.
+    :returns:
+        The version number as a string, or ``None`` if not available.
+        Checked at compile time for ``jpg``, run-time otherwise.
+    :raises ValueError: If the codec is not defined in this version of Pillow.
+    """
+    if not check_codec(feature):
+        return None
+
+    codec, lib = codecs[feature]
+
+    version = getattr(Image.core, f"{lib}_version")
+
+    if feature == "libtiff":
+        return version.split("\n")[0].split("Version ")[1]
+
+    return version
+
+
+def get_supported_codecs() -> list[str]:
+    """
+    :returns: A list of all supported codecs.
+    """
+    return [f for f in codecs if check_codec(f)]
+
+
+features: dict[str, tuple[str, str, str | None]] = {
+    "raqm": ("PIL._imagingft", "HAVE_RAQM", "raqm_version"),
+    "fribidi": ("PIL._imagingft", "HAVE_FRIBIDI", "fribidi_version"),
+    "harfbuzz": ("PIL._imagingft", "HAVE_HARFBUZZ", "harfbuzz_version"),
+    "libjpeg_turbo": ("PIL._imaging", "HAVE_LIBJPEGTURBO", "libjpeg_turbo_version"),
+    "mozjpeg": ("PIL._imaging", "HAVE_MOZJPEG", "libjpeg_turbo_version"),
+    "zlib_ng": ("PIL._imaging", "HAVE_ZLIBNG", "zlib_ng_version"),
+    "libimagequant": ("PIL._imaging", "HAVE_LIBIMAGEQUANT", "imagequant_version"),
+    "xcb": ("PIL._imaging", "HAVE_XCB", None),
+}
+
+
+def check_feature(feature: str) -> bool | None:
+    """
+    Checks if a feature is available.
+
+    :param feature: The feature to check for.
+    :returns: ``True`` if available, ``False`` if unavailable, ``None`` if unknown.
+    :raises ValueError: If the feature is not defined in this version of Pillow.
+    """
+    if feature not in features:
+        msg = f"Unknown feature {feature}"
+        raise ValueError(msg)
+
+    module, flag, ver = features[feature]
+
+    try:
+        imported_module = __import__(module, fromlist=["PIL"])
+        return getattr(imported_module, flag)
+    except ModuleNotFoundError:
+        return None
+    except ImportError as ex:
+        warnings.warn(str(ex))
+        return None
+
+
+def version_feature(feature: str) -> str | None:
+    """
+    :param feature: The feature to check for.
+    :returns: The version number as a string, or ``None`` if not available.
+    :raises ValueError: If the feature is not defined in this version of Pillow.
+    """
+    if not check_feature(feature):
+        return None
+
+    module, flag, ver = features[feature]
+
+    if ver is None:
+        return None
+
+    return getattr(__import__(module, fromlist=[ver]), ver)
+
+
+def get_supported_features() -> list[str]:
+    """
+    :returns: A list of all supported features.
+    """
+    return [f for f in features if check_feature(f)]
+
+
+def check(feature: str) -> bool | None:
+    """
+    :param feature: A module, codec, or feature name.
+    :returns:
+        ``True`` if the module, codec, or feature is available,
+        ``False`` or ``None`` otherwise.
+    """
+
+    if feature in modules:
+        return check_module(feature)
+    if feature in codecs:
+        return check_codec(feature)
+    if feature in features:
+        return check_feature(feature)
+    warnings.warn(f"Unknown feature '{feature}'.", stacklevel=2)
+    return False
+
+
+def version(feature: str) -> str | None:
+    """
+    :param feature:
+        The module, codec, or feature to check for.
+    :returns:
+        The version number as a string, or ``None`` if unknown or not available.
+    """
+    if feature in modules:
+        return version_module(feature)
+    if feature in codecs:
+        return version_codec(feature)
+    if feature in features:
+        return version_feature(feature)
+    return None
+
+
+def get_supported() -> list[str]:
+    """
+    :returns: A list of all supported modules, features, and codecs.
+    """
+
+    ret = get_supported_modules()
+    ret.extend(get_supported_features())
+    ret.extend(get_supported_codecs())
+    return ret
+
+
+def pilinfo(out: IO[str] | None = None, supported_formats: bool = True) -> None:
+    """
+    Prints information about this installation of Pillow.
+    This function can be called with ``python3 -m PIL``.
+    It can also be called with ``python3 -m PIL.report`` or ``python3 -m PIL --report``
+    to have "supported_formats" set to ``False``, omitting the list of all supported
+    image file formats.
+
+    :param out:
+        The output stream to print to. Defaults to ``sys.stdout`` if ``None``.
+    :param supported_formats:
+        If ``True``, a list of all supported image file formats will be printed.
+    """
+
+    if out is None:
+        out = sys.stdout
+
+    Image.init()
+
+    print("-" * 68, file=out)
+    print(f"Pillow {PIL.__version__}", file=out)
+    py_version_lines = sys.version.splitlines()
+    print(f"Python {py_version_lines[0].strip()}", file=out)
+    for py_version in py_version_lines[1:]:
+        print(f"       {py_version.strip()}", file=out)
+    print("-" * 68, file=out)
+    print(f"Python executable is {sys.executable or 'unknown'}", file=out)
+    if sys.prefix != sys.base_prefix:
+        print(f"Environment Python files loaded from {sys.prefix}", file=out)
+    print(f"System Python files loaded from {sys.base_prefix}", file=out)
+    print("-" * 68, file=out)
+    print(
+        f"Python Pillow modules loaded from {os.path.dirname(Image.__file__)}",
+        file=out,
+    )
+    print(
+        f"Binary Pillow modules loaded from {os.path.dirname(Image.core.__file__)}",
+        file=out,
+    )
+    print("-" * 68, file=out)
+
+    for name, feature in [
+        ("pil", "PIL CORE"),
+        ("tkinter", "TKINTER"),
+        ("freetype2", "FREETYPE2"),
+        ("littlecms2", "LITTLECMS2"),
+        ("webp", "WEBP"),
+        ("avif", "AVIF"),
+        ("jpg", "JPEG"),
+        ("jpg_2000", "OPENJPEG (JPEG2000)"),
+        ("zlib", "ZLIB (PNG/ZIP)"),
+        ("libtiff", "LIBTIFF"),
+        ("raqm", "RAQM (Bidirectional Text)"),
+        ("libimagequant", "LIBIMAGEQUANT (Quantization method)"),
+        ("xcb", "XCB (X protocol)"),
+    ]:
+        if check(name):
+            v: str | None = None
+            if name == "jpg":
+                libjpeg_turbo_version = version_feature("libjpeg_turbo")
+                if libjpeg_turbo_version is not None:
+                    v = "mozjpeg" if check_feature("mozjpeg") else "libjpeg-turbo"
+                    v += " " + libjpeg_turbo_version
+            if v is None:
+                v = version(name)
+            if v is not None:
+                version_static = name in ("pil", "jpg")
+                if name == "littlecms2":
+                    # this check is also in src/_imagingcms.c:setup_module()
+                    version_static = tuple(int(x) for x in v.split(".")) < (2, 7)
+                t = "compiled for" if version_static else "loaded"
+                if name == "zlib":
+                    zlib_ng_version = version_feature("zlib_ng")
+                    if zlib_ng_version is not None:
+                        v += ", compiled for zlib-ng " + zlib_ng_version
+                elif name == "raqm":
+                    for f in ("fribidi", "harfbuzz"):
+                        v2 = version_feature(f)
+                        if v2 is not None:
+                            v += f", {f} {v2}"
+                print("---", feature, "support ok,", t, v, file=out)
+            else:
+                print("---", feature, "support ok", file=out)
+        else:
+            print("***", feature, "support not installed", file=out)
+    print("-" * 68, file=out)
+
+    if supported_formats:
+        extensions = collections.defaultdict(list)
+        for ext, i in Image.EXTENSION.items():
+            extensions[i].append(ext)
+
+        for i in sorted(Image.ID):
+            line = f"{i}"
+            if i in Image.MIME:
+                line = f"{line} {Image.MIME[i]}"
+            print(line, file=out)
+
+            if i in extensions:
+                print(
+                    "Extensions: {}".format(", ".join(sorted(extensions[i]))), file=out
+                )
+
+            features = []
+            if i in Image.OPEN:
+                features.append("open")
+            if i in Image.SAVE:
+                features.append("save")
+            if i in Image.SAVE_ALL:
+                features.append("save_all")
+            if i in Image.DECODERS:
+                features.append("decode")
+            if i in Image.ENCODERS:
+                features.append("encode")
+
+            print("Features: {}".format(", ".join(features)), file=out)
+            print("-" * 68, file=out)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/report.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/report.py
new file mode 100644
index 0000000000000000000000000000000000000000..d2815e8455e2ead803de4417314987ce7e9b7598
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/PIL/report.py
@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .features import pilinfo
+
+pilinfo(supported_formats=False)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/README.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/README.txt
new file mode 100644
index 0000000000000000000000000000000000000000..273f6251a7f9d9c4142522e9ab1d699a8ab1bad6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/README.txt
@@ -0,0 +1,2 @@
+This directory exists so that 3rd party packages can be installed
+here.  Read the source for site.py for more details.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14268dad6e4ebdafe08968324d312aaff17d4001
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/__pycache__/typing_extensions.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:45ff332424e3b3d99eee35d8a6627fb999028e9d9481657beb626fe79e6aeb0c
+size 182737
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b320f600d2b359ce1fca91a2d5f24fe6be3545e4
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__init__.py
@@ -0,0 +1,239 @@
+# don't import any costly modules
+import os
+import sys
+
+report_url = (
+    "https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml"
+)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Setuptools is replacing distutils. Support for replacing "
+        "an already imported distutils is deprecated. In the future, "
+        "this condition will fail. "
+        f"Register concerns at {report_url}"
+    )
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    if which == 'stdlib':
+        import warnings
+
+        warnings.warn(
+            "Reliance on distutils from stdlib is deprecated. Users "
+            "must rely on setuptools to provide the distutils module. "
+            "Avoid importing distutils or import setuptools first, "
+            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
+            f"Register concerns at {report_url}"
+        )
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns) -> None:
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:  # noqa: BLE001 # intentional broad fallback
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self) -> None:
+        insert_shim()
+
+    def __exit__(self, exc: object, value: object, tb: object) -> None:
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5f1e8a0ec7b77fd4ea65d31dbacc0fa6343d2d56
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..114cc22327a3eed82b59733b3de3f123a4a90d2e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/__pycache__/override.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/override.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/override.py
new file mode 100644
index 0000000000000000000000000000000000000000..2cc433a4a55e3b41fa31089918fb62096092f89f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_distutils_hack/override.py
@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..7baa8c4b68127d5cdf0be9a799429e61347c2694
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__init__.py
@@ -0,0 +1,33 @@
+# This is a stub package designed to roughly emulate the _yaml
+# extension module, which previously existed as a standalone module
+# and has been moved into the `yaml` package namespace.
+# It does not perfectly mimic its old counterpart, but should get
+# close enough for anyone who's relying on it even when they shouldn't.
+import yaml
+
+# in some circumstances, the yaml module we imoprted may be from a different version, so we need
+# to tread carefully when poking at it here (it may not have the attributes we expect)
+if not getattr(yaml, '__with_libyaml__', False):
+    from sys import version_info
+
+    exc = ModuleNotFoundError if version_info >= (3, 6) else ImportError
+    raise exc("No module named '_yaml'")
+else:
+    from yaml._yaml import *
+    import warnings
+    warnings.warn(
+        'The _yaml extension module is now located at yaml._yaml'
+        ' and its location is subject to change.  To use the'
+        ' LibYAML-based parser and emitter, import from `yaml`:'
+        ' `from yaml import CLoader as Loader, CDumper as Dumper`.',
+        DeprecationWarning
+    )
+    del warnings
+    # Don't `del yaml` here because yaml is actually an existing
+    # namespace member of _yaml.
+
+__name__ = '_yaml'
+# If the module is top-level (i.e. not a part of any specific package)
+# then the attribute should be set to ''.
+# https://docs.python.org/3.8/library/types.html
+__package__ = ''
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..677103d710719a47a5969b529f2d33ffcc6a9aef
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/_yaml/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..13734ecac7501953843b99eef680987bad705350
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/METADATA
@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: anyio
+Version: 4.15.1
+Summary: High-level concurrency and networking framework on top of asyncio or Trio
+Author-email: Alex Grönholm <alex.gronholm@nextday.fi>
+License-Expression: MIT
+Project-URL: Documentation, https://anyio.readthedocs.io/en/latest/
+Project-URL: Changelog, https://anyio.readthedocs.io/en/stable/versionhistory.html
+Project-URL: Source code, https://github.com/agronholm/anyio
+Project-URL: Issue tracker, https://github.com/agronholm/anyio/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Framework :: AnyIO
+Classifier: Typing :: Typed
+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 :: 3.15
+Classifier: Programming Language :: Python :: Free Threading :: 2 - Beta
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Requires-Dist: exceptiongroup>=1.0.2; python_version < "3.11"
+Requires-Dist: idna>=2.8
+Requires-Dist: typing_extensions>=4.16.0; python_version < "3.15"
+Provides-Extra: trio
+Requires-Dist: trio>=0.32.0; extra == "trio"
+Dynamic: license-file
+
+.. image:: https://github.com/agronholm/anyio/actions/workflows/test.yml/badge.svg
+  :target: https://github.com/agronholm/anyio/actions/workflows/test.yml
+  :alt: Build Status
+.. image:: https://coveralls.io/repos/github/agronholm/anyio/badge.svg?branch=master
+  :target: https://coveralls.io/github/agronholm/anyio?branch=master
+  :alt: Code Coverage
+.. image:: https://readthedocs.org/projects/anyio/badge/?version=latest
+  :target: https://anyio.readthedocs.io/en/latest/?badge=latest
+  :alt: Documentation
+.. image:: https://badges.gitter.im/gitterHQ/gitter.svg
+  :target: https://gitter.im/python-trio/AnyIO
+  :alt: Gitter chat
+.. image:: https://tidelift.com/badges/package/pypi/anyio
+  :target: https://tidelift.com/subscription/pkg/pypi-anyio
+  :alt: Tidelift
+
+AnyIO is an asynchronous networking and concurrency library that works on top of either asyncio_ or
+Trio_. It implements Trio-like `structured concurrency`_ (SC) on top of asyncio and works in harmony
+with the native SC of Trio itself.
+
+Applications and libraries written against AnyIO's API will run unmodified on either asyncio_ or
+Trio_. AnyIO can also be adopted into a library or application incrementally – bit by bit, no full
+refactoring necessary. It will blend in with the native libraries of your chosen backend.
+
+To find out why you might want to use AnyIO's APIs instead of asyncio's, you can read about it
+`here <https://anyio.readthedocs.io/en/stable/why.html>`_.
+
+Documentation
+-------------
+
+View full documentation at: https://anyio.readthedocs.io/
+
+Features
+--------
+
+AnyIO offers the following functionality:
+
+* Task groups (nurseries_ in trio terminology)
+* High-level networking (TCP, UDP and UNIX sockets)
+
+  * `Happy eyeballs`_ algorithm for TCP connections (more robust than that of asyncio on Python
+    3.8)
+  * async/await style UDP sockets (unlike asyncio where you still have to use Transports and
+    Protocols)
+
+* A versatile API for byte streams and object streams
+* Inter-task synchronization and communication (locks, conditions, events, semaphores, object
+  streams and futures)
+* Worker threads
+* Subprocesses
+* Subinterpreter support for code parallelization (on Python 3.13 and later)
+* Asynchronous file I/O (using worker threads)
+* Signal handling
+* Asynchronous versions of the functools_ and itertools_ modules
+
+AnyIO also comes with its own pytest_ plugin which also supports asynchronous fixtures.
+It even works with the popular Hypothesis_ library.
+
+.. _asyncio: https://docs.python.org/3/library/asyncio.html
+.. _Trio: https://github.com/python-trio/trio
+.. _structured concurrency: https://en.wikipedia.org/wiki/Structured_concurrency
+.. _nurseries: https://trio.readthedocs.io/en/stable/reference-core.html#nurseries-and-spawning
+.. _Happy eyeballs: https://en.wikipedia.org/wiki/Happy_Eyeballs
+.. _pytest: https://docs.pytest.org/en/latest/
+.. _functools: https://docs.python.org/3/library/functools.html
+.. _itertools: https://docs.python.org/3/library/itertools.html
+.. _Hypothesis: https://hypothesis.works/
+
+Security contact information
+----------------------------
+
+To report a security vulnerability, please use the `Tidelift security contact`_.
+Tidelift will coordinate the fix and disclosure.
+
+.. _Tidelift security contact: https://tidelift.com/security
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..76924cc5cb3a30faf80efaa0562c0e77dd64aa6d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/RECORD
@@ -0,0 +1,100 @@
+anyio-4.15.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+anyio-4.15.1.dist-info/METADATA,sha256=BDrstXGvcYnopsUo9djjJUXxss36r3YdUebVtn6jyoE,4733
+anyio-4.15.1.dist-info/RECORD,,
+anyio-4.15.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+anyio-4.15.1.dist-info/entry_points.txt,sha256=_d6Yu6uiaZmNe0CydowirE9Cmg7zUL2g08tQpoS3Qvc,39
+anyio-4.15.1.dist-info/licenses/LICENSE,sha256=U2GsncWPLvX9LpsJxoKXwX8ElQkJu8gCO9uC6s8iwrA,1081
+anyio-4.15.1.dist-info/top_level.txt,sha256=QglSMiWX8_5dpoVAEIHdEYzvqFMdSYWmCj6tYw2ITkQ,6
+anyio/__init__.py,sha256=OfroYRjIUw_JFj0Zwh1JAaajMQg4VqtoAt0XoOHDRwE,7602
+anyio/__pycache__/__init__.cpython-311.pyc,,
+anyio/__pycache__/_lazyimport.cpython-311.pyc,,
+anyio/__pycache__/from_thread.cpython-311.pyc,,
+anyio/__pycache__/functools.cpython-311.pyc,,
+anyio/__pycache__/itertools.cpython-311.pyc,,
+anyio/__pycache__/lowlevel.cpython-311.pyc,,
+anyio/__pycache__/pytest_plugin.cpython-311.pyc,,
+anyio/__pycache__/to_interpreter.cpython-311.pyc,,
+anyio/__pycache__/to_process.cpython-311.pyc,,
+anyio/__pycache__/to_thread.cpython-311.pyc,,
+anyio/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_backends/__pycache__/__init__.cpython-311.pyc,,
+anyio/_backends/__pycache__/_asyncio.cpython-311.pyc,,
+anyio/_backends/__pycache__/_trio.cpython-311.pyc,,
+anyio/_backends/_asyncio.py,sha256=Vqy7O1ymmEpxTiPzehSuBCVTziGALNV-BbsIRaKXsg4,107767
+anyio/_backends/_trio.py,sha256=Gs8XzX0IeBvje8IEZtJmpNylKCUAChKv7I_YZi3wlmg,45715
+anyio/_core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/_core/__pycache__/__init__.cpython-311.pyc,,
+anyio/_core/__pycache__/_asyncio_selector_thread.cpython-311.pyc,,
+anyio/_core/__pycache__/_concurrency_utils.cpython-311.pyc,,
+anyio/_core/__pycache__/_contextmanagers.cpython-311.pyc,,
+anyio/_core/__pycache__/_eventloop.cpython-311.pyc,,
+anyio/_core/__pycache__/_exceptions.cpython-311.pyc,,
+anyio/_core/__pycache__/_fileio.cpython-311.pyc,,
+anyio/_core/__pycache__/_futures.cpython-311.pyc,,
+anyio/_core/__pycache__/_resources.cpython-311.pyc,,
+anyio/_core/__pycache__/_signals.cpython-311.pyc,,
+anyio/_core/__pycache__/_sockets.cpython-311.pyc,,
+anyio/_core/__pycache__/_streams.cpython-311.pyc,,
+anyio/_core/__pycache__/_subprocesses.cpython-311.pyc,,
+anyio/_core/__pycache__/_synchronization.cpython-311.pyc,,
+anyio/_core/__pycache__/_tasks.cpython-311.pyc,,
+anyio/_core/__pycache__/_tempfile.cpython-311.pyc,,
+anyio/_core/__pycache__/_testing.cpython-311.pyc,,
+anyio/_core/__pycache__/_typedattr.cpython-311.pyc,,
+anyio/_core/_asyncio_selector_thread.py,sha256=2PdxFM3cs02Kp6BSppbvmRT7q7asreTW5FgBxEsflBo,5626
+anyio/_core/_concurrency_utils.py,sha256=kvRXMrnDqgQTBkZc-f279-lBnZM4YbSToXqhnAUCfSc,4522
+anyio/_core/_contextmanagers.py,sha256=YInBCabiEeS-UaP_Jdxa1CaFC71ETPW8HZTHIM8Rsc8,7215
+anyio/_core/_eventloop.py,sha256=ByZUeJD9alMfcyTseRo5IzTO0IltEul_Gyq9iqSjqDk,6658
+anyio/_core/_exceptions.py,sha256=B4ZhLkBQT4tI6vShv4-GJui492IJsoIDTw1FQJEkmAI,5618
+anyio/_core/_fileio.py,sha256=q--ft9h5Y_FRLzhAnoYrXf3tOuZ8ZyIN2A9mCfMbZRc,34163
+anyio/_core/_futures.py,sha256=YQq5uhnCnKQMQD62tOLfzEm7dUXY3GQorJdH6ghfgIQ,6177
+anyio/_core/_resources.py,sha256=Ld5duCe9NwgPfI7EIOh3CMIBYQ7rq6ZQEa7CFS0u9Ec,450
+anyio/_core/_signals.py,sha256=mjTBB2hTKNPRlU0IhnijeQedpWOGERDiMjSlJQsFrug,1016
+anyio/_core/_sockets.py,sha256=C8b-3w5H9n0Fo4g7X8WJvk0m6CGh6NVAAFtieBGHK3g,35289
+anyio/_core/_streams.py,sha256=FczFwIgDpnkK0bODWJXMpsUJYdvAD04kaUaGzJU8DK0,1806
+anyio/_core/_subprocesses.py,sha256=TMBuGNILz-47w5t9vayJ1GpCpDT6LxsMohJDFCewIRc,7938
+anyio/_core/_synchronization.py,sha256=ggsd74QPd846faA2HQeT07ONQ5HQ1S78gy8mvB3qCrw,21658
+anyio/_core/_tasks.py,sha256=J2dhM_Jq3Grsfg_enNWpRz2SxfM15uLt-pEfvoQq3uA,15391
+anyio/_core/_tempfile.py,sha256=IgoBCFaPhrFvsF9KHcCcrnCRn-UqMfw0WRdSDWgxAiI,19726
+anyio/_core/_testing.py,sha256=ZRucLh5kqhiFWAJMMbd8yZ6uIvz0rq3WwL72ldosxAU,2340
+anyio/_core/_typedattr.py,sha256=gt9Dzn-IL0QW14aHPDD8PAtq95FYKNNupHyf37xZGPQ,2607
+anyio/_lazyimport.py,sha256=LCjnYanIfYE9G-Dv_EsqNLDuVRppNicWZjCTfS9-sJU,6082
+anyio/abc/__init__.py,sha256=XIVvCI2c6oyaOcqXe94k2rzU5_s7-ZNnlxGTk34H4T0,3050
+anyio/abc/__pycache__/__init__.cpython-311.pyc,,
+anyio/abc/__pycache__/_eventloop.cpython-311.pyc,,
+anyio/abc/__pycache__/_resources.cpython-311.pyc,,
+anyio/abc/__pycache__/_sockets.cpython-311.pyc,,
+anyio/abc/__pycache__/_streams.cpython-311.pyc,,
+anyio/abc/__pycache__/_subprocesses.cpython-311.pyc,,
+anyio/abc/__pycache__/_tasks.cpython-311.pyc,,
+anyio/abc/__pycache__/_testing.cpython-311.pyc,,
+anyio/abc/_eventloop.py,sha256=0-UwgB351rkocCt8m3fjTmcNx2Fxn52nUoujG5DzMvU,11127
+anyio/abc/_resources.py,sha256=hrb0LXUgHSp3i8G6W8JJchdzKXgg1m0T-L7udXmv2y0,900
+anyio/abc/_sockets.py,sha256=jQWnPX7iDIDyvyvVkbuFhjezw4oI2WggzbW6Vl2-eqs,13162
+anyio/abc/_streams.py,sha256=IMeOPPutFXRbyeAutxV1HJe7FUQZYp2qKrJJpP1DCv0,7620
+anyio/abc/_subprocesses.py,sha256=CDqU1p0HuBS0pXUzBW_hbfhihTJRM67n__7qZmoPU84,2123
+anyio/abc/_tasks.py,sha256=HBPpT72aOy0bwMAxBCKmnXsR328wCYRjYm3iaVw2fQo,7070
+anyio/abc/_testing.py,sha256=A9Y8RAClIPn1A0aNHBN8YoaRy_MKOpbFGEbTHAXgB6U,2145
+anyio/from_thread.py,sha256=iZZbfcNySi4wAcx1_cxAQE4J0YZC88qRMIYqQ6SF9sc,19415
+anyio/functools.py,sha256=T4JS8IXq-x1S0Lbo2owF8l9fza2KypO147QLeyz4cjs,11797
+anyio/itertools.py,sha256=TS7_UCa2Y3cggtaLlWHbjOyf6QhPfQUdPduNW-ddXTE,16255
+anyio/lowlevel.py,sha256=QyWkvfetbCH0mHkqv1yxGwOaiZ7fyxhpZkHWOXPV5JU,6280
+anyio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/pytest_plugin.py,sha256=oLXyOstvRZW3VVbqIODhZsPt4jSz2UGh44YeG2nJXx0,14516
+anyio/streams/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+anyio/streams/__pycache__/__init__.cpython-311.pyc,,
+anyio/streams/__pycache__/buffered.cpython-311.pyc,,
+anyio/streams/__pycache__/file.cpython-311.pyc,,
+anyio/streams/__pycache__/memory.cpython-311.pyc,,
+anyio/streams/__pycache__/stapled.cpython-311.pyc,,
+anyio/streams/__pycache__/text.cpython-311.pyc,,
+anyio/streams/__pycache__/tls.cpython-311.pyc,,
+anyio/streams/buffered.py,sha256=u7hCD8SNrYHcutG6K5wEiy1F88-pizgjvEFM22Kq2Cw,6746
+anyio/streams/file.py,sha256=6jujI2m-QJITqqKFamrupX_DNsU7y2Fz3omLZxOLuY0,4524
+anyio/streams/memory.py,sha256=rpxNzDMag9PCOynBqN64KyuAfAPB41vFyRP-Npo-lE0,10793
+anyio/streams/stapled.py,sha256=UJ2Rgt0NUmM1VovRNOoZoic960lcbDjb3vhfZg3b_Z0,4845
+anyio/streams/text.py,sha256=BcVAGJw1VRvtIqnv-o0Rb0pwH7p8vwlvl21xHq522ag,5765
+anyio/streams/tls.py,sha256=fqLmxvULFO9rvxGyJ33VPrOIN7E3eiU1q90BkmKigQ8,15818
+anyio/to_interpreter.py,sha256=ATnoT6kei9wDmQZtXTA3SsY4CK7XKr8Ta4_x5i6pbTw,7100
+anyio/to_process.py,sha256=p6n8j0nreJUl1DEkR_9PL6KRoKtNqFxORTn8qZBvn94,9850
+anyio/to_thread.py,sha256=8MPVrrQq8ttGvV21cSd68rMto5bhxJ0-i9CupXag5Gs,2750
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..13013d7b49be5a84c3ee5931b06285b9553cf5d0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/entry_points.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..44dd9bdc3039122cc98014c1439ca254313fd014
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[pytest11]
+anyio = anyio.pytest_plugin
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..104eebf5a3002fccdaceef3a4cb936173c1c2035
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/licenses/LICENSE
@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Alex Grönholm
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/top_level.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c77c069ecc9b7f8b1f97dbcfec905725db0253a8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio-4.15.1.dist-info/top_level.txt
@@ -0,0 +1 @@
+anyio
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..30a3a16151bef66d432cb8e06ad858c3ada002fd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__init__.py
@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ._lazyimport import (
+    fix_package_names,
+    install_lazy_importer,
+    set_deprecated_aliases,
+)
+
+if TYPE_CHECKING or not install_lazy_importer():
+    from ._core._concurrency_utils import amap as amap
+    from ._core._concurrency_utils import as_completed as as_completed
+    from ._core._concurrency_utils import gather as gather
+    from ._core._contextmanagers import (
+        AsyncContextManagerMixin as AsyncContextManagerMixin,
+    )
+    from ._core._contextmanagers import ContextManagerMixin as ContextManagerMixin
+    from ._core._eventloop import current_time as current_time
+    from ._core._eventloop import get_all_backends as get_all_backends
+    from ._core._eventloop import get_available_backends as get_available_backends
+    from ._core._eventloop import get_cancelled_exc_class as get_cancelled_exc_class
+    from ._core._eventloop import run as run
+    from ._core._eventloop import sleep as sleep
+    from ._core._eventloop import sleep_forever as sleep_forever
+    from ._core._eventloop import sleep_until as sleep_until
+    from ._core._exceptions import BrokenResourceError as BrokenResourceError
+    from ._core._exceptions import BrokenWorkerInterpreter as BrokenWorkerInterpreter
+    from ._core._exceptions import BrokenWorkerProcess as BrokenWorkerProcess
+    from ._core._exceptions import BusyResourceError as BusyResourceError
+    from ._core._exceptions import ClosedResourceError as ClosedResourceError
+    from ._core._exceptions import ConnectionFailed as ConnectionFailed
+    from ._core._exceptions import DelimiterNotFound as DelimiterNotFound
+    from ._core._exceptions import EndOfStream as EndOfStream
+    from ._core._exceptions import FutureAlreadyFinished as FutureAlreadyFinished
+    from ._core._exceptions import FutureCancelled as FutureCancelled
+    from ._core._exceptions import FutureFailed as FutureFailed
+    from ._core._exceptions import FutureNotFinished as FutureNotFinished
+    from ._core._exceptions import IncompleteRead as IncompleteRead
+    from ._core._exceptions import NoEventLoopError as NoEventLoopError
+    from ._core._exceptions import RunFinishedError as RunFinishedError
+    from ._core._exceptions import TaskCancelled as TaskCancelled
+    from ._core._exceptions import TaskFailed as TaskFailed
+    from ._core._exceptions import TaskNotFinished as TaskNotFinished
+    from ._core._exceptions import (
+        TypedAttributeLookupError as TypedAttributeLookupError,
+    )
+    from ._core._exceptions import WouldBlock as WouldBlock
+    from ._core._fileio import AsyncFile as AsyncFile
+    from ._core._fileio import Path as Path
+    from ._core._fileio import open_file as open_file
+    from ._core._fileio import wrap_file as wrap_file
+    from ._core._futures import Future as Future
+    from ._core._resources import aclose_forcefully as aclose_forcefully
+    from ._core._signals import open_signal_receiver as open_signal_receiver
+    from ._core._sockets import TCPConnectable as TCPConnectable
+    from ._core._sockets import UNIXConnectable as UNIXConnectable
+    from ._core._sockets import as_connectable as as_connectable
+    from ._core._sockets import connect_tcp as connect_tcp
+    from ._core._sockets import connect_unix as connect_unix
+    from ._core._sockets import (
+        create_connected_udp_socket as create_connected_udp_socket,
+    )
+    from ._core._sockets import (
+        create_connected_unix_datagram_socket as create_connected_unix_datagram_socket,
+    )
+    from ._core._sockets import create_tcp_listener as create_tcp_listener
+    from ._core._sockets import create_udp_socket as create_udp_socket
+    from ._core._sockets import (
+        create_unix_datagram_socket as create_unix_datagram_socket,
+    )
+    from ._core._sockets import create_unix_listener as create_unix_listener
+    from ._core._sockets import getaddrinfo as getaddrinfo
+    from ._core._sockets import getnameinfo as getnameinfo
+    from ._core._sockets import notify_closing as notify_closing
+    from ._core._sockets import wait_readable as wait_readable
+    from ._core._sockets import wait_socket_readable as wait_socket_readable
+    from ._core._sockets import wait_socket_writable as wait_socket_writable
+    from ._core._sockets import wait_writable as wait_writable
+    from ._core._streams import (
+        create_memory_object_stream as create_memory_object_stream,
+    )
+    from ._core._subprocesses import open_process as open_process
+    from ._core._subprocesses import run_process as run_process
+    from ._core._synchronization import CapacityLimiter as CapacityLimiter
+    from ._core._synchronization import (
+        CapacityLimiterStatistics as CapacityLimiterStatistics,
+    )
+    from ._core._synchronization import Condition as Condition
+    from ._core._synchronization import ConditionStatistics as ConditionStatistics
+    from ._core._synchronization import Event as Event
+    from ._core._synchronization import EventStatistics as EventStatistics
+    from ._core._synchronization import Lock as Lock
+    from ._core._synchronization import LockStatistics as LockStatistics
+    from ._core._synchronization import ResourceGuard as ResourceGuard
+    from ._core._synchronization import Semaphore as Semaphore
+    from ._core._synchronization import SemaphoreStatistics as SemaphoreStatistics
+    from ._core._tasks import TASK_STATUS_IGNORED as TASK_STATUS_IGNORED
+    from ._core._tasks import CancelScope as CancelScope
+    from ._core._tasks import TaskHandle as TaskHandle
+    from ._core._tasks import create_task_group as create_task_group
+    from ._core._tasks import current_effective_deadline as current_effective_deadline
+    from ._core._tasks import fail_after as fail_after
+    from ._core._tasks import fail_at as fail_at
+    from ._core._tasks import move_on_after as move_on_after
+    from ._core._tasks import move_on_at as move_on_at
+    from ._core._tempfile import NamedTemporaryFile as NamedTemporaryFile
+    from ._core._tempfile import SpooledTemporaryFile as SpooledTemporaryFile
+    from ._core._tempfile import TemporaryDirectory as TemporaryDirectory
+    from ._core._tempfile import TemporaryFile as TemporaryFile
+    from ._core._tempfile import gettempdir as gettempdir
+    from ._core._tempfile import gettempdirb as gettempdirb
+    from ._core._tempfile import mkdtemp as mkdtemp
+    from ._core._tempfile import mkstemp as mkstemp
+    from ._core._testing import TaskInfo as TaskInfo
+    from ._core._testing import get_current_task as get_current_task
+    from ._core._testing import get_running_tasks as get_running_tasks
+    from ._core._testing import wait_all_tasks_blocked as wait_all_tasks_blocked
+    from ._core._typedattr import TypedAttributeProvider as TypedAttributeProvider
+    from ._core._typedattr import TypedAttributeSet as TypedAttributeSet
+    from ._core._typedattr import typed_attribute as typed_attribute
+
+    # ruff: isort: off
+    from . import (
+        abc as abc,
+    )
+    from . import (
+        from_thread as from_thread,
+    )
+    from . import (
+        functools as functools,
+    )
+    from . import (
+        itertools as itertools,
+    )
+    from . import (
+        lowlevel as lowlevel,
+    )
+    from . import (
+        to_interpreter as to_interpreter,
+    )
+    from . import (
+        to_process as to_process,
+    )
+    from . import (
+        to_thread as to_thread,
+    )
+
+    fix_package_names()
+    set_deprecated_aliases(
+        {
+            "BrokenWorkerIntepreter": "anyio.BrokenWorkerInterpreter",
+        }
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..13ee373b9a1017bccb8276987152a0e8bff67224
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/_lazyimport.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/_lazyimport.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ceb184823ee417baf1da028698c19dc75a512a37
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/_lazyimport.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/from_thread.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/from_thread.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a82deda31828f743932c2ec6c3ec5d2eb51a04cf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/from_thread.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/functools.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/functools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..30d3266f5f46b951c92ac0b2a43b6eede43796f3
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/functools.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/itertools.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/itertools.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..57721c7457e7574e9a534e69495695e100df1a05
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/itertools.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/lowlevel.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/lowlevel.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97bbf9cff6e746eda9d6a4ed25f5f8dab5091775
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/lowlevel.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/pytest_plugin.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/pytest_plugin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7035a5a14f41f2c319fa231cd735d8e5a01901a3
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/pytest_plugin.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_interpreter.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_interpreter.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46ef00875c560ef5a08707fd969c1a93b8a6dc69
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_interpreter.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_process.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_process.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b040663f64febfa2655240c12c9c520dcda289e7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_process.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_thread.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_thread.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb074ddf26e44141788d4e849f6e4f2333bdd11d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/__pycache__/to_thread.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..47b2d1008f7f3f46c01a76417ed1b1f8d82fed02
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6122f7fab7124420436eef96c4c99ed5e3d9d5e3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_asyncio.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c2884668b64f0af28d79b7d5d55cb8c6b717296698908b75ef0f66ed59036146
+size 160813
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_trio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_trio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5ac291eee52e86f0519c365564b7810fbf411d62
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/__pycache__/_trio.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_asyncio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_asyncio.py
new file mode 100644
index 0000000000000000000000000000000000000000..7eba257c962819dbf8192b51185a4f5faa4746fd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_asyncio.py
@@ -0,0 +1,3201 @@
+from __future__ import annotations
+
+import array
+import asyncio
+import concurrent.futures
+import math
+import os
+import socket
+import sys
+import threading
+import weakref
+from asyncio import (
+    AbstractEventLoop,
+    CancelledError,
+    all_tasks,
+    create_task,
+    current_task,
+    get_running_loop,
+    sleep,
+)
+from asyncio.base_events import _run_until_complete_cb  # type: ignore[attr-defined]
+from collections import OrderedDict, deque
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Collection,
+    Coroutine,
+    Iterable,
+    Sequence,
+)
+from concurrent.futures import Future
+from contextlib import AbstractContextManager, suppress
+from contextvars import Context, copy_context
+from dataclasses import dataclass, field
+from functools import partial, wraps
+from inspect import (
+    CORO_RUNNING,
+    CORO_SUSPENDED,
+    getcoroutinestate,
+)
+from io import IOBase
+from os import PathLike
+from queue import Queue
+from signal import Signals
+from socket import AddressFamily, SocketKind
+from threading import Thread
+from types import CodeType, TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Literal,
+    ParamSpec,
+    TypeVar,
+    cast,
+)
+from weakref import WeakKeyDictionary
+
+from .. import (
+    CapacityLimiterStatistics,
+    EventStatistics,
+    LockStatistics,
+    TaskInfo,
+    abc,
+)
+from .._core._eventloop import (
+    claim_worker_thread,
+    set_current_async_library,
+    threadlocals,
+)
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+    RunFinishedError,
+    WouldBlock,
+)
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._streams import create_memory_object_stream
+from .._core._synchronization import (
+    CapacityLimiter as BaseCapacityLimiter,
+)
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import Lock as BaseLock
+from .._core._synchronization import (
+    ResourceGuard,
+    SemaphoreStatistics,
+)
+from .._core._synchronization import Semaphore as BaseSemaphore
+from .._core._tasks import CancelScope as BaseCancelScope
+from .._core._tasks import TaskHandle
+from ..abc import (
+    AsyncBackend,
+    IPSockAddrType,
+    SocketListener,
+    UDPPacketType,
+    UNIXDatagramPacketType,
+)
+from ..abc._tasks import call_for_coroutine, get_callable_name, get_coro_name
+from ..lowlevel import RunVar, _run_vars
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+    from ..abc._eventloop import StrOrBytesPath
+    from ..streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+else:
+    FileDescriptorLike = object
+
+if sys.version_info >= (3, 11):
+    from asyncio import Runner
+    from typing import Self, TypeVarTuple, Unpack
+else:
+    import contextvars
+    import enum
+    import signal
+    from asyncio import coroutines, events, exceptions, tasks
+
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import Self, TypeVarTuple, Unpack
+
+    class _State(enum.Enum):
+        CREATED = "created"
+        INITIALIZED = "initialized"
+        CLOSED = "closed"
+
+    class Runner:
+        # Copied from CPython 3.11
+        def __init__(
+            self,
+            *,
+            debug: bool | None = None,
+            loop_factory: Callable[[], AbstractEventLoop] | None = None,
+        ):
+            self._state = _State.CREATED
+            self._debug = debug
+            self._loop_factory = loop_factory
+            self._loop: AbstractEventLoop | None = None
+            self._context = None
+            self._interrupt_count = 0
+            self._set_event_loop = False
+
+        def __enter__(self) -> Self:
+            self._lazy_init()
+            return self
+
+        def __exit__(
+            self,
+            exc_type: type[BaseException] | None,
+            exc_val: BaseException | None,
+            exc_tb: TracebackType | None,
+        ) -> None:
+            self.close()
+
+        def close(self) -> None:
+            """Shutdown and close event loop."""
+            loop = self._loop
+            if self._state is not _State.INITIALIZED or loop is None:
+                return
+            try:
+                _cancel_all_tasks(loop)
+                loop.run_until_complete(loop.shutdown_asyncgens())
+                if hasattr(loop, "shutdown_default_executor"):
+                    loop.run_until_complete(loop.shutdown_default_executor())
+                else:
+                    loop.run_until_complete(_shutdown_default_executor(loop))
+            finally:
+                if self._set_event_loop:
+                    events.set_event_loop(None)
+                loop.close()
+                self._loop = None
+                self._state = _State.CLOSED
+
+        def get_loop(self) -> AbstractEventLoop:
+            """Return embedded event loop."""
+            self._lazy_init()
+            return self._loop
+
+        def run(self, coro: Coroutine[T_Retval], *, context=None) -> T_Retval:
+            """Run a coroutine inside the embedded event loop."""
+            if not coroutines.iscoroutine(coro):
+                raise ValueError(f"a coroutine was expected, got {coro!r}")
+
+            if events._get_running_loop() is not None:
+                # fail fast with short traceback
+                raise RuntimeError(
+                    "Runner.run() cannot be called from a running event loop"
+                )
+
+            self._lazy_init()
+
+            if context is None:
+                context = self._context
+            task = context.run(self._loop.create_task, coro)
+
+            if (
+                threading.current_thread() is threading.main_thread()
+                and signal.getsignal(signal.SIGINT) is signal.default_int_handler
+            ):
+                sigint_handler = partial(self._on_sigint, main_task=task)
+                try:
+                    signal.signal(signal.SIGINT, sigint_handler)
+                except ValueError:
+                    # `signal.signal` may throw if `threading.main_thread` does
+                    # not support signals (e.g. embedded interpreter with signals
+                    # not registered - see gh-91880)
+                    sigint_handler = None
+            else:
+                sigint_handler = None
+
+            self._interrupt_count = 0
+            try:
+                return self._loop.run_until_complete(task)
+            except exceptions.CancelledError:
+                if self._interrupt_count > 0:
+                    uncancel = getattr(task, "uncancel", None)
+                    if uncancel is not None and uncancel() == 0:
+                        raise KeyboardInterrupt  # noqa: B904
+                raise  # CancelledError
+            finally:
+                if (
+                    sigint_handler is not None
+                    and signal.getsignal(signal.SIGINT) is sigint_handler
+                ):
+                    signal.signal(signal.SIGINT, signal.default_int_handler)
+
+        def _lazy_init(self) -> None:
+            if self._state is _State.CLOSED:
+                raise RuntimeError("Runner is closed")
+            if self._state is _State.INITIALIZED:
+                return
+            if self._loop_factory is None:
+                self._loop = events.new_event_loop()
+                if not self._set_event_loop:
+                    # Call set_event_loop only once to avoid calling
+                    # attach_loop multiple times on child watchers
+                    events.set_event_loop(self._loop)
+                    self._set_event_loop = True
+            else:
+                self._loop = self._loop_factory()
+            if self._debug is not None:
+                self._loop.set_debug(self._debug)
+            self._context = contextvars.copy_context()
+            self._state = _State.INITIALIZED
+
+        def _on_sigint(self, signum, frame, main_task: asyncio.Task) -> None:
+            self._interrupt_count += 1
+            if self._interrupt_count == 1 and not main_task.done():
+                main_task.cancel()
+                # wakeup loop if it is blocked by select() with long timeout
+                self._loop.call_soon_threadsafe(lambda: None)
+                return
+            raise KeyboardInterrupt()
+
+    def _cancel_all_tasks(loop: AbstractEventLoop) -> None:
+        to_cancel = tasks.all_tasks(loop)
+        if not to_cancel:
+            return
+
+        for task in to_cancel:
+            task.cancel()
+
+        loop.run_until_complete(tasks.gather(*to_cancel, return_exceptions=True))
+
+        for task in to_cancel:
+            if task.cancelled():
+                continue
+            if task.exception() is not None:
+                loop.call_exception_handler(
+                    {
+                        "message": "unhandled exception during asyncio.run() shutdown",
+                        "exception": task.exception(),
+                        "task": task,
+                    }
+                )
+
+    async def _shutdown_default_executor(loop: AbstractEventLoop) -> None:
+        """Schedule the shutdown of the default executor."""
+
+        def _do_shutdown(future: asyncio.futures.Future) -> None:
+            try:
+                loop._default_executor.shutdown(wait=True)  # type: ignore[attr-defined]
+                loop.call_soon_threadsafe(future.set_result, None)
+            except Exception as ex:
+                loop.call_soon_threadsafe(future.set_exception, ex)
+
+        loop._executor_shutdown_called = True
+        if loop._default_executor is None:
+            return
+        future = loop.create_future()
+        thread = threading.Thread(target=_do_shutdown, args=(future,))
+        thread.start()
+        try:
+            await future
+        finally:
+            thread.join()
+
+
+T_Retval = TypeVar("T_Retval")
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
+P = ParamSpec("P")
+
+_root_task: RunVar[asyncio.Task[Any] | None] = RunVar("_root_task")
+
+
+def find_root_task() -> asyncio.Task:
+    root_task = _root_task.get(None)
+    if root_task is not None and not root_task.done():
+        return root_task
+
+    # Look for a task that has been started via run_until_complete()
+    for task in all_tasks():
+        if task._callbacks and not task.done():
+            for cb, context in task._callbacks:
+                if (
+                    cb is _run_until_complete_cb
+                    or getattr(cb, "__module__", None) == "uvloop.loop"
+                ):
+                    _root_task.set(task)
+
+                    def _unset(t: asyncio.Task[Any]) -> None:
+                        if vars := _run_vars.get(t.get_loop()):
+                            vars.pop(_root_task, None)
+
+                    # Register a callback to break the task -> loop -> _run_var[loop][_root_task] -> task cycle
+                    # Also run it in its own context to not create another reference.
+                    # We can't use RunVar.reset() here since these are called synchronously
+                    # and thus lowlevel.current_token() (which RunVar.reset() depends on) fails.
+                    task.add_done_callback(_unset, context=context)
+                    return task
+
+    # Look up the topmost task in the AnyIO task tree, if possible
+    task = cast(asyncio.Task, current_task())
+    state = _task_states.get(task)
+    if state:
+        cancel_scope = state.cancel_scope
+        while cancel_scope and cancel_scope._parent_scope is not None:
+            cancel_scope = cancel_scope._parent_scope
+
+        if cancel_scope is not None:
+            return cast(asyncio.Task, cancel_scope._host_task)
+
+    return task
+
+
+def _task_started(task: asyncio.Task) -> bool:
+    """Return ``True`` if the task has been started and has not finished."""
+    # The task coro should never be None here, as we never add finished tasks to the
+    # task list
+    coro = task.get_coro()
+    assert coro is not None
+    return getcoroutinestate(coro) in (CORO_RUNNING, CORO_SUSPENDED)
+
+
+#
+# Timeouts and cancellation
+#
+
+
+def is_anyio_cancellation(exc: CancelledError) -> bool:
+    # Sometimes third party frameworks catch a CancelledError and raise a new one, so as
+    # a workaround we have to look at the previous ones in __context__ too for a
+    # matching cancel message
+    while True:
+        if (
+            exc.args
+            and isinstance(exc.args[0], str)
+            and exc.args[0].startswith("Cancelled via cancel scope ")
+        ):
+            return True
+
+        if isinstance(exc.__context__, CancelledError):
+            exc = exc.__context__
+            continue
+
+        return False
+
+
+class CancelScope(BaseCancelScope):
+    __slots__ = (
+        "_active",
+        "_cancel_called",
+        "_cancel_handle",
+        "_cancel_reason",
+        "_cancelled_caught",
+        "_child_scopes",
+        "_deadline",
+        "_host_task",
+        "_parent_scope",
+        "_pending_uncancellations",
+        "_shield",
+        "_tasks",
+        "_timeout_handle",
+    )
+
+    def __new__(cls, *, deadline: float = math.inf, shield: bool = False) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, deadline: float = math.inf, shield: bool = False):
+        self._deadline = deadline
+        self._shield = shield
+        self._parent_scope: CancelScope | None = None
+        self._child_scopes: set[CancelScope] = set()
+        self._cancel_called = False
+        self._cancel_reason: str | None = None
+        self._cancelled_caught = False
+        self._active = False
+        self._timeout_handle: asyncio.TimerHandle | None = None
+        self._cancel_handle: asyncio.Handle | None = None
+        self._tasks: set[asyncio.Task] = set()
+        self._host_task: asyncio.Task | None = None
+        if sys.version_info >= (3, 11):
+            self._pending_uncancellations: int | None = 0
+        else:
+            self._pending_uncancellations = None
+
+    def __enter__(self) -> Self:
+        if self._active:
+            raise RuntimeError(
+                "Each CancelScope may only be used for a single 'with' block"
+            )
+
+        self._host_task = host_task = cast(asyncio.Task, current_task())
+        self._tasks.add(host_task)
+        try:
+            task_state = _task_states[host_task]
+        except KeyError:
+            task_state = TaskState(None, self)
+            _task_states[host_task] = task_state
+        else:
+            self._parent_scope = task_state.cancel_scope
+            task_state.cancel_scope = self
+            if self._parent_scope is not None:
+                # If using an eager task factory, the parent scope may not even contain
+                # the host task
+                self._parent_scope._child_scopes.add(self)
+                self._parent_scope._tasks.discard(host_task)
+
+        self._timeout()
+        self._active = True
+
+        # Start cancelling the host task if the scope was cancelled before entering
+        if self._cancel_called:
+            self._deliver_cancellation(self)
+
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        del exc_tb
+
+        if not self._active:
+            raise RuntimeError("This cancel scope is not active")
+        if current_task() is not self._host_task:
+            raise RuntimeError(
+                "Attempted to exit cancel scope in a different task than it was "
+                "entered in"
+            )
+
+        assert self._host_task is not None
+        host_task_state = _task_states.get(self._host_task)
+        if host_task_state is None or host_task_state.cancel_scope is not self:
+            raise RuntimeError(
+                "Attempted to exit a cancel scope that isn't the current tasks's "
+                "current cancel scope"
+            )
+
+        try:
+            self._active = False
+            if self._timeout_handle:
+                self._timeout_handle.cancel()
+                self._timeout_handle = None
+
+            self._tasks.remove(self._host_task)
+            if self._parent_scope is not None:
+                self._parent_scope._child_scopes.remove(self)
+                self._parent_scope._tasks.add(self._host_task)
+
+            host_task_state.cancel_scope = self._parent_scope
+
+            # Restart the cancellation effort in the closest visible, cancelled parent
+            # scope if necessary
+            self._restart_cancellation_in_parent()
+
+            # We only swallow the exception iff it was an AnyIO CancelledError, either
+            # directly as exc_val or inside an exception group and there are no cancelled
+            # parent cancel scopes visible to us here
+            if self._cancel_called and not self._parent_cancellation_is_visible_to_us:
+                # For each level-cancel() call made on the host task, call uncancel()
+                while self._pending_uncancellations:
+                    self._host_task.uncancel()
+                    self._pending_uncancellations -= 1
+
+                # Update cancelled_caught and check for exceptions we must not swallow
+                if isinstance(exc_val, BaseExceptionGroup):
+                    cancelleds_caught, remaining = exc_val.split(
+                        lambda exc: (
+                            isinstance(exc, CancelledError)
+                            and is_anyio_cancellation(exc)
+                        )
+                    )
+
+                    if cancelleds_caught is None:
+                        return False
+
+                    self._cancelled_caught = True
+
+                    if remaining is None:
+                        return True
+
+                    context = remaining.__context__
+                    try:
+                        # Preserve __cause__ and __suppress_context__ by avoiding `raise
+                        # ... from ...`
+                        raise remaining
+                    finally:
+                        # Preserve __context__
+                        remaining.__context__ = context
+                        del context
+                else:
+                    if isinstance(exc_val, CancelledError) and is_anyio_cancellation(
+                        exc_val
+                    ):
+                        self._cancelled_caught = True
+                        return True
+                    else:
+                        return False
+            else:
+                if self._pending_uncancellations:
+                    assert self._parent_scope is not None
+                    assert self._parent_scope._pending_uncancellations is not None
+                    self._parent_scope._pending_uncancellations += (
+                        self._pending_uncancellations
+                    )
+                    self._pending_uncancellations = 0
+
+                return False
+        finally:
+            self._host_task = None
+            del exc_val
+
+    @property
+    def _effectively_cancelled(self) -> bool:
+        cancel_scope: CancelScope | None = self
+        while cancel_scope is not None:
+            if cancel_scope._cancel_called:
+                return True
+
+            if cancel_scope.shield:
+                return False
+
+            cancel_scope = cancel_scope._parent_scope
+
+        return False
+
+    @property
+    def _parent_cancellation_is_visible_to_us(self) -> bool:
+        return (
+            self._parent_scope is not None
+            and not self.shield
+            and self._parent_scope._effectively_cancelled
+        )
+
+    def _timeout(self) -> None:
+        if self._deadline != math.inf:
+            loop = get_running_loop()
+            if loop.time() >= self._deadline:
+                self.cancel("deadline exceeded")
+            else:
+                self._timeout_handle = loop.call_at(self._deadline, self._timeout)
+
+    def _deliver_cancellation(self, origin: CancelScope) -> bool:
+        """
+        Deliver cancellation to directly contained tasks and nested cancel scopes.
+
+        Schedule another run at the end if we still have tasks eligible for
+        cancellation.
+
+        :param origin: the cancel scope that originated the cancellation
+        :return: ``True`` if the delivery needs to be retried on the next cycle
+
+        """
+        should_retry = False
+        current = current_task()
+        for task in self._tasks:
+            # Always skip tasks that are already done (see issue #1111)
+            if task.done():
+                continue
+
+            should_retry = True
+            if task._must_cancel:  # type: ignore[attr-defined]
+                continue
+
+            # The task is eligible for cancellation if it has started
+            if task is not current and (task is self._host_task or _task_started(task)):
+                waiter = task._fut_waiter  # type: ignore[attr-defined]
+                if not isinstance(waiter, asyncio.Future) or not waiter.done():
+                    task.cancel(origin._cancel_reason)
+                    if (
+                        task is origin._host_task
+                        and origin._pending_uncancellations is not None
+                    ):
+                        origin._pending_uncancellations += 1
+
+        # Deliver cancellation to child scopes that aren't shielded or running their own
+        # cancellation callbacks
+        for scope in self._child_scopes:
+            if not scope._shield and not scope.cancel_called:
+                should_retry = scope._deliver_cancellation(origin) or should_retry
+
+        # Schedule another callback if there are still tasks left
+        if origin is self:
+            if should_retry:
+                self._cancel_handle = get_running_loop().call_soon(
+                    self._deliver_cancellation, origin
+                )
+            else:
+                self._cancel_handle = None
+
+        return should_retry
+
+    def _restart_cancellation_in_parent(self) -> None:
+        """
+        Restart the cancellation effort in the closest directly cancelled parent scope.
+
+        """
+        scope = self._parent_scope
+        while scope is not None:
+            if scope._cancel_called:
+                if scope._cancel_handle is None:
+                    scope._deliver_cancellation(scope)
+
+                break
+
+            # No point in looking beyond any shielded scope
+            if scope._shield:
+                break
+
+            scope = scope._parent_scope
+
+    def _reparent(self, new_parent: CancelScope) -> None:
+        """
+        Move this active scope from its current parent to ``new_parent``.
+
+        Used by :meth:`TaskGroup.start` to move a task that has just called
+        ``task_status.started()`` into the target task group's cancel scope.
+        """
+        if self._parent_scope is new_parent:
+            return
+
+        if self._parent_scope is not None:
+            self._parent_scope._child_scopes.discard(self)
+
+        self._parent_scope = new_parent
+        new_parent._child_scopes.add(self)
+
+        # If the new parent (or an ancestor) is already cancelled, (re)start the
+        # delivery loop to ensure we're cancelled at next checkpoint like Trio.
+        self._restart_cancellation_in_parent()
+
+    def cancel(self, reason: str | None = None) -> None:
+        if not self._cancel_called:
+            if self._timeout_handle:
+                self._timeout_handle.cancel()
+                self._timeout_handle = None
+
+            self._cancel_called = True
+            self._cancel_reason = f"Cancelled via cancel scope {id(self):x}"
+            if task := current_task():
+                self._cancel_reason += f" by {task}"
+
+            if reason:
+                self._cancel_reason += f"; reason: {reason}"
+
+            if self._host_task is not None:
+                self._deliver_cancellation(self)
+
+    @property
+    def deadline(self) -> float:
+        return self._deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self._deadline = float(value)
+        if self._timeout_handle is not None:
+            self._timeout_handle.cancel()
+            self._timeout_handle = None
+
+        if self._active and not self._cancel_called:
+            self._timeout()
+
+    @property
+    def cancel_called(self) -> bool:
+        return self._cancel_called
+
+    @property
+    def cancelled_caught(self) -> bool:
+        return self._cancelled_caught
+
+    @property
+    def shield(self) -> bool:
+        return self._shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        if self._shield != value:
+            self._shield = value
+            if not value:
+                self._restart_cancellation_in_parent()
+
+
+#
+# Task states
+#
+
+
+class TaskState:
+    """
+    Encapsulates auxiliary task information that cannot be added to the Task instance
+    itself because there are no guarantees about its implementation.
+    """
+
+    __slots__ = "__weakref__", "cancel_scope", "parent_id"
+
+    def __init__(self, parent_id: int | None, cancel_scope: CancelScope | None):
+        self.parent_id = parent_id
+        self.cancel_scope = cancel_scope
+
+
+_task_states: WeakKeyDictionary[asyncio.Task, TaskState] = WeakKeyDictionary()
+
+
+#
+# Task groups
+#
+
+
+class _AsyncioTaskStatus(abc.TaskStatus[T_contra]):
+    def __init__(
+        self,
+        future: asyncio.Future,
+        parent_id: int,
+        target_scope: CancelScope,
+        spawn_scope: CancelScope,
+    ):
+        self._future = future
+        self._parent_id = parent_id
+        # The eventual parent scope for this spawn_scope
+        # (after task_status.started() has been called)
+        self._target_scope = target_scope
+        # The task's own cancel scope, also held by its TaskHandle
+        self._spawn_scope = spawn_scope
+
+    def started(self, value: T_contra | None = None) -> None:
+        task = cast(asyncio.Task, current_task())
+        _task_states[task].parent_id = self._parent_id
+        if self._future.done():
+            if not self._future.cancelled():
+                raise RuntimeError("called 'started' twice on the same task status")
+            else:
+                # Caller of start() was cancelled, nothing to reparent
+                return
+
+        self._future.set_result(value)
+        self._spawn_scope._reparent(self._target_scope)
+
+
+if sys.version_info >= (3, 12):
+    _eager_task_factory_code: CodeType | None = asyncio.eager_task_factory.__code__
+else:
+    _eager_task_factory_code = None
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self.cancel_scope: CancelScope = CancelScope()
+        self._entered = False
+        self._exceptions: list[BaseException] = []
+        self._tasks: set[asyncio.Task] = set()
+        self._on_completed_fut: asyncio.Future[None] | None = None
+
+    async def __aenter__(self) -> Self:
+        if self._entered:
+            raise RuntimeError("TaskGroup cannot be entered more than once")
+
+        self._entered = True
+
+        self.cancel_scope.__enter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        try:
+            if exc_val is not None:
+                self.cancel_scope.cancel()
+                if not isinstance(exc_val, CancelledError):
+                    self._exceptions.append(exc_val)
+
+            loop = get_running_loop()
+            try:
+                if self._tasks:
+                    with CancelScope() as wait_scope:
+                        while self._tasks:
+                            self._on_completed_fut = loop.create_future()
+
+                            try:
+                                await self._on_completed_fut
+                            except CancelledError as exc:
+                                # Shield the scope against further cancellation attempts,
+                                # as they're not productive (#695)
+                                wait_scope.shield = True
+                                self.cancel_scope.cancel()
+
+                                # Set exc_val from the cancellation exception if it was
+                                # previously unset. However, we should not replace a native
+                                # cancellation exception with one raise by a cancel scope.
+                                if exc_val is None or (
+                                    isinstance(exc_val, CancelledError)
+                                    and not is_anyio_cancellation(exc)
+                                ):
+                                    exc_val = exc
+
+                            self._on_completed_fut = None
+                else:
+                    # If there are no child tasks to wait on, run at least one checkpoint
+                    # anyway
+                    await AsyncIOBackend.cancel_shielded_checkpoint()
+
+                if self._exceptions:
+                    # The exception that got us here should already have been
+                    # added to self._exceptions so it's ok to break exception
+                    # chaining and avoid adding a "During handling of above..."
+                    # for each nesting level.
+                    raise BaseExceptionGroup(
+                        "unhandled errors in a TaskGroup", self._exceptions
+                    ) from None
+                elif exc_val:
+                    raise exc_val
+            except BaseException as exc:
+                if self.cancel_scope.__exit__(type(exc), exc, exc.__traceback__):
+                    return True
+
+                raise
+
+            return self.cancel_scope.__exit__(exc_type, exc_val, exc_tb)
+        finally:
+            del exc_val, exc_tb, self._exceptions
+
+    def _spawn(
+        self,
+        coro: Coroutine[Any, Any, T_co],
+        name: object,
+        task_status: _AsyncioTaskStatus | None = None,
+    ) -> TaskHandle[T_co]:
+        task_status_future = task_status._future if task_status is not None else None
+
+        def task_done(_task: asyncio.Task) -> None:
+            if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None:
+                asyncio.future_discard_from_awaited_by(
+                    _task, self.cancel_scope._host_task
+                )
+
+            task_state = _task_states[_task]
+            assert task_state.cancel_scope is not None
+            assert _task in task_state.cancel_scope._tasks
+            task_state.cancel_scope._tasks.remove(_task)
+            self._tasks.remove(task)
+            del _task_states[_task]
+
+            if self._on_completed_fut is not None and not self._tasks:
+                try:
+                    self._on_completed_fut.set_result(None)
+                except asyncio.InvalidStateError:
+                    pass
+
+            try:
+                exc = _task.exception()
+            except CancelledError as e:
+                while isinstance(e.__context__, CancelledError):
+                    e = e.__context__
+
+                exc = e
+
+            if exc is not None:
+                # The future can only be in the cancelled state if the host task was
+                # cancelled, so return immediately instead of adding one more
+                # CancelledError to the exceptions list
+                if task_status_future is not None and task_status_future.cancelled():
+                    return
+
+                if task_status_future is None or task_status_future.done():
+                    if not isinstance(exc, CancelledError):
+                        self._exceptions.append(exc)
+
+                    if not self.cancel_scope._effectively_cancelled:
+                        self.cancel_scope.cancel()
+                else:
+                    task_status_future.set_exception(exc)
+            elif task_status_future is not None and not task_status_future.done():
+                task_status_future.set_exception(
+                    RuntimeError("Child exited without calling task_status.started()")
+                )
+
+        if task_status_future is not None:
+            parent_id = id(current_task())
+            caller_state = _task_states.get(cast(asyncio.Task, current_task()))
+            if caller_state is not None and caller_state.cancel_scope is not None:
+                initial_scope = caller_state.cancel_scope
+            else:
+                # The caller is an unmanaged task (no task state)
+                initial_scope = self.cancel_scope
+        else:
+            parent_id = id(self.cancel_scope._host_task)
+            initial_scope = self.cancel_scope
+
+        spawn_scope = task_status._spawn_scope if task_status is not None else None
+        handle = TaskHandle(coro, name, cancel_scope=spawn_scope)
+        loop = asyncio.get_running_loop()
+        wrapper_coro = handle._run_coro()
+        try:
+            if (
+                (factory := loop.get_task_factory())
+                and getattr(factory, "__code__", None) is _eager_task_factory_code
+                and (closure := getattr(factory, "__closure__", None))
+            ):
+                custom_task_constructor = closure[0].cell_contents
+                task = custom_task_constructor(
+                    wrapper_coro, loop=loop, name=handle.name
+                )
+            else:
+                task = loop.create_task(wrapper_coro, name=handle.name)
+        except BaseException:
+            with suppress(BaseException):
+                wrapper_coro.close()
+
+            with suppress(BaseException):
+                coro.close()
+
+            raise
+
+        # Make the spawned task inherit the initial cancel scope
+        _task_states[task] = TaskState(parent_id=parent_id, cancel_scope=initial_scope)
+        initial_scope._tasks.add(task)
+        self._tasks.add(task)
+        if sys.version_info >= (3, 14) and self.cancel_scope._host_task is not None:
+            asyncio.future_add_to_awaited_by(task, self.cancel_scope._host_task)
+
+        task.add_done_callback(task_done)
+        return handle
+
+    def create_task(
+        self,
+        coro: Coroutine[Any, Any, T_co],
+        *,
+        name: object = None,
+        context: Context | None = None,
+    ) -> TaskHandle[T_co]:
+        if not isinstance(coro, Coroutine):
+            raise TypeError(f"expected a coroutine, got {coro.__class__.__qualname__}")
+
+        if not self._entered or not self.cancel_scope._active:
+            coro.close()
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        final_name = get_coro_name(coro, name)
+
+        if context is not None:
+            return context.run(self._spawn, coro, name=final_name)
+        else:
+            return self._spawn(coro, name=final_name)
+
+    async def start(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+        return_handle: Literal[False, True] = False,
+    ) -> Any:
+        if not self._entered or not self.cancel_scope._active:
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+        # Until task_status.started() is called, a task spawned via start() belongs to
+        # the *caller's* cancel scope, not the target group's, so cancelling the group
+        # does not cancel a task that hasn't reported startup yet. The
+        # task_status.started() call moves the task's cancel scope to this task group's
+        # cancel scope.
+        #
+        # The caller may be an unmanaged task (no _task_states entry), in which case
+        # fall back to the group's own scope.
+        future: asyncio.Future = asyncio.Future()
+        final_name = get_callable_name(func, name)
+        task_status: _AsyncioTaskStatus[Any] = _AsyncioTaskStatus(
+            future, id(self.cancel_scope._host_task), self.cancel_scope, CancelScope()
+        )
+        coro = call_for_coroutine(func, args, task_status=task_status)
+        handle = self._spawn(coro, final_name, task_status)
+
+        # If the task raises an exception after sending a start value without a switch
+        # point between, the task group is cancelled and this method never proceeds to
+        # process the completed future. That's why we have to have a shielded cancel
+        # scope here.
+        try:
+            await future
+        except BaseException:
+            if handle.status is TaskHandle.Status.PENDING:
+                # Cancel the task and wait for it to exit before returning
+                handle.cancel()
+                with CancelScope(shield=True):
+                    await handle.wait()
+
+            raise
+
+        if return_handle:
+            handle._start_value = future.result()
+            return handle
+        else:
+            return future.result()
+
+
+#
+# Threads
+#
+
+_Retval_Queue_Type = tuple[T_Retval | None, BaseException | None]
+
+
+class WorkerThread(Thread):
+    MAX_IDLE_TIME = 10  # seconds
+
+    def __init__(
+        self,
+        root_task: asyncio.Task,
+        workers: set[WorkerThread],
+        idle_workers: deque[WorkerThread],
+    ):
+        kwargs: dict[str, Any] = {}
+        if sys.version_info >= (3, 14):
+            kwargs["context"] = Context()
+
+        super().__init__(name="AnyIO worker thread", **kwargs)
+        self.root_task = root_task
+        self.workers = workers
+        self.idle_workers = idle_workers
+        self.loop = root_task._loop
+        self.queue: Queue[
+            tuple[Context, Callable, tuple, asyncio.Future, CancelScope] | None
+        ] = Queue(2)
+        self.idle_since = AsyncIOBackend.current_time()
+        self.stopping = False
+
+    def _report_result(
+        self, future: asyncio.Future, result: Any, exc: BaseException | None
+    ) -> None:
+        self.idle_since = AsyncIOBackend.current_time()
+        if not self.stopping:
+            self.idle_workers.append(self)
+
+        if not future.cancelled():
+            if exc is not None:
+                if isinstance(exc, StopIteration):
+                    new_exc = RuntimeError("coroutine raised StopIteration")
+                    new_exc.__cause__ = exc
+                    exc = new_exc
+
+                future.set_exception(exc)
+            else:
+                future.set_result(result)
+
+    def run(self) -> None:
+        with claim_worker_thread(AsyncIOBackend, self.loop):
+            while True:
+                item = self.queue.get()
+                if item is None:
+                    # Shutdown command received
+                    return
+
+                context, func, args, future, cancel_scope = item
+                if not future.cancelled():
+                    result = None
+                    exception: BaseException | None = None
+                    threadlocals.current_cancel_scope = cancel_scope
+                    try:
+                        result = context.run(func, *args)
+                    except BaseException as exc:
+                        exception = exc
+                    finally:
+                        del threadlocals.current_cancel_scope
+
+                    try:
+                        self.loop.call_soon_threadsafe(
+                            self._report_result, future, result, exception
+                        )
+                    except RuntimeError:
+                        if not self.loop.is_closed():
+                            raise
+
+                    del result, exception
+
+                self.queue.task_done()
+                del item, context, func, args, future, cancel_scope
+
+    def stop(self, f: asyncio.Task | None = None) -> None:
+        self.stopping = True
+        self.queue.put_nowait(None)
+        self.workers.discard(self)
+        try:
+            self.idle_workers.remove(self)
+        except ValueError:
+            pass
+
+
+_threadpool_idle_workers: RunVar[deque[WorkerThread]] = RunVar(
+    "_threadpool_idle_workers"
+)
+_threadpool_workers: RunVar[set[WorkerThread]] = RunVar("_threadpool_workers")
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class StreamReaderWrapper(abc.ByteReceiveStream):
+    _stream: asyncio.StreamReader
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        data = await self._stream.read(max_bytes)
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        self._stream.set_exception(ClosedResourceError())
+        await AsyncIOBackend.checkpoint()
+
+
+@dataclass(eq=False)
+class StreamWriterWrapper(abc.ByteSendStream):
+    _stream: asyncio.StreamWriter
+    _closed: bool = field(init=False, default=False)
+
+    async def send(self, item: bytes) -> None:
+        await AsyncIOBackend.checkpoint_if_cancelled()
+        stream_paused = self._stream._protocol._paused  # type: ignore[attr-defined]
+        try:
+            self._stream.write(item)
+            await self._stream.drain()
+        except (ConnectionResetError, BrokenPipeError, RuntimeError) as exc:
+            # If closed by us and/or the peer:
+            # * on stdlib, drain() raises ConnectionResetError or BrokenPipeError
+            # * on uvloop and Winloop, write() eventually starts raising RuntimeError
+            if self._closed:
+                raise ClosedResourceError from exc
+            elif self._stream.is_closing():
+                raise BrokenResourceError from exc
+
+            raise
+
+        if not stream_paused:
+            await AsyncIOBackend.cancel_shielded_checkpoint()
+
+    async def aclose(self) -> None:
+        self._closed = True
+        self._stream.close()
+        await AsyncIOBackend.checkpoint()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: asyncio.subprocess.Process
+    _stdin: StreamWriterWrapper | None
+    _stdout: StreamReaderWrapper | None
+    _stderr: StreamReaderWrapper | None
+    _exited: asyncio.Event
+    _transport: asyncio.SubprocessTransport
+
+    async def aclose(self) -> None:
+        with CancelScope(shield=True) as scope:
+            # We need to close the underlying pipe_transports as well to allow a
+            # process blocking on full buffers to receive SIGPIPE and exit.
+            if self._stdin:
+                await self._stdin.aclose()
+                if pipe := self._transport.get_pipe_transport(0):
+                    pipe.close()
+            if self._stdout:
+                await self._stdout.aclose()
+                if pipe := self._transport.get_pipe_transport(1):
+                    pipe.close()
+            if self._stderr:
+                await self._stderr.aclose()
+                if pipe := self._transport.get_pipe_transport(2):
+                    pipe.close()
+
+            scope.shield = False
+            try:
+                await self.wait()
+            except BaseException:
+                scope.shield = True
+                # Closing the transport on asyncio also handles sending kill
+                self._transport.close()
+                await self.wait()
+                raise
+
+    async def wait(self) -> int:
+        await self._exited.wait()
+        assert self._process.returncode is not None
+        return self._process.returncode
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: int) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> int | None:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> abc.ByteSendStream | None:
+        return self._stdin
+
+    @property
+    def stdout(self) -> abc.ByteReceiveStream | None:
+        return self._stdout
+
+    @property
+    def stderr(self) -> abc.ByteReceiveStream | None:
+        return self._stderr
+
+
+def _forcibly_shutdown_process_pool_on_exit(
+    workers: set[Process], _task: object
+) -> None:
+    """
+    Forcibly shuts down worker processes belonging to this event loop."""
+    child_watcher: asyncio.AbstractChildWatcher | None = None  # type: ignore[name-defined]
+    if sys.version_info < (3, 12):
+        try:
+            child_watcher = asyncio.get_event_loop_policy().get_child_watcher()
+        except NotImplementedError:
+            pass
+
+    # Close as much as possible (w/o async/await) to avoid warnings
+    for process in workers.copy():
+        if process.returncode is not None:
+            continue
+
+        process._stdin._stream._transport.close()  # type: ignore[union-attr]
+        process._stdout._stream._transport.close()  # type: ignore[union-attr]
+        process._stderr._stream._transport.close()  # type: ignore[union-attr]
+        process.kill()
+        if child_watcher:
+            child_watcher.remove_child_handler(process.pid)
+
+
+async def _shutdown_process_pool_on_exit(workers: set[abc.Process]) -> None:
+    """
+    Shuts down worker processes belonging to this event loop.
+
+    NOTE: this only works when the event loop was started using asyncio.run() or
+    anyio.run().
+
+    """
+    process: abc.Process
+    try:
+        await sleep(math.inf)
+    except asyncio.CancelledError:
+        workers = workers.copy()
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        for process in workers:
+            await process.aclose()
+
+
+#
+# Sockets and networking
+#
+
+
+class StreamProtocol(asyncio.Protocol):
+    read_queue: deque[bytes]
+    read_event: asyncio.Event
+    write_event: asyncio.Event
+    exception: Exception | None = None
+    is_at_eof: bool = False
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.read_queue = deque()
+        self.read_event = asyncio.Event()
+        self.write_event = asyncio.Event()
+        self.write_event.set()
+        cast(asyncio.Transport, transport).set_write_buffer_limits(0)
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        if exc:
+            self.exception = exc
+
+        self.read_event.set()
+        self.write_event.set()
+
+    def data_received(self, data: bytes) -> None:
+        # ProactorEventloop sometimes sends bytearray instead of bytes
+        self.read_queue.append(bytes(data))
+        self.read_event.set()
+
+    def eof_received(self) -> bool | None:
+        self.is_at_eof = True
+        self.read_event.set()
+        return True
+
+    def pause_writing(self) -> None:
+        self.write_event = asyncio.Event()
+
+    def resume_writing(self) -> None:
+        self.write_event.set()
+
+
+class DatagramProtocol(asyncio.DatagramProtocol):
+    read_queue: deque[tuple[bytes, IPSockAddrType]]
+    read_event: asyncio.Event
+    write_event: asyncio.Event
+    closed_event: asyncio.Event
+    exception: Exception | None = None
+
+    def connection_made(self, transport: asyncio.BaseTransport) -> None:
+        self.read_queue = deque(maxlen=100)  # arbitrary value
+        self.read_event = asyncio.Event()
+        self.write_event = asyncio.Event()
+        self.closed_event = asyncio.Event()
+        self.write_event.set()
+
+    def connection_lost(self, exc: Exception | None) -> None:
+        self.read_event.set()
+        self.write_event.set()
+        self.closed_event.set()
+
+    def datagram_received(self, data: bytes, addr: IPSockAddrType) -> None:
+        addr = convert_ipv6_sockaddr(addr)
+        self.read_queue.append((data, addr))
+        self.read_event.set()
+
+    def error_received(self, exc: Exception) -> None:
+        self.exception = exc
+
+    def pause_writing(self) -> None:
+        self.write_event.clear()
+
+    def resume_writing(self) -> None:
+        self.write_event.set()
+
+
+class SocketStream(abc.SocketStream):
+    def __init__(self, transport: asyncio.Transport, protocol: StreamProtocol):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        with self._receive_guard:
+            if (
+                not self._protocol.read_event.is_set()
+                and not self._transport.is_closing()
+                and not self._protocol.is_at_eof
+            ):
+                self._transport.resume_reading()
+                await self._protocol.read_event.wait()
+                self._transport.pause_reading()
+            else:
+                await AsyncIOBackend.checkpoint()
+
+            try:
+                chunk = self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                elif self._protocol.exception:
+                    raise BrokenResourceError from self._protocol.exception
+                else:
+                    raise EndOfStream from None
+
+            if len(chunk) > max_bytes:
+                # Split the oversized chunk
+                chunk, leftover = chunk[:max_bytes], chunk[max_bytes:]
+                self._protocol.read_queue.appendleft(leftover)
+
+            # If the read queue is empty, clear the flag so that the next call will
+            # block until data is available
+            if not self._protocol.read_queue:
+                self._protocol.read_event.clear()
+
+        return chunk
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            await AsyncIOBackend.checkpoint()
+
+            if self._closed:
+                raise ClosedResourceError
+            elif self._protocol.exception is not None:
+                raise BrokenResourceError from self._protocol.exception
+
+            try:
+                self._transport.write(item)
+            except RuntimeError as exc:
+                if self._transport.is_closing():
+                    raise BrokenResourceError from exc
+                else:
+                    raise
+
+            await self._protocol.write_event.wait()
+
+    async def send_eof(self) -> None:
+        try:
+            self._transport.write_eof()
+        except OSError:
+            pass
+
+    async def aclose(self) -> None:
+        self._closed = True
+        if not self._transport.is_closing():
+            try:
+                self._transport.write_eof()
+            except OSError:
+                pass
+
+            self._transport.close()
+            await sleep(0)
+            self._transport.abort()
+
+
+class _RawSocketMixin:
+    _receive_future: asyncio.Future | None = None
+    _send_future: asyncio.Future | None = None
+    _closing = False
+
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+    def _wait_until_readable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future:
+        def callback(f: object) -> None:
+            del self._receive_future
+            loop.remove_reader(self.__raw_socket)
+
+        f = self._receive_future = asyncio.Future()
+        loop.add_reader(self.__raw_socket, f.set_result, None)
+        f.add_done_callback(callback)
+        return f
+
+    def _wait_until_writable(self, loop: asyncio.AbstractEventLoop) -> asyncio.Future:
+        def callback(f: object) -> None:
+            del self._send_future
+            loop.remove_writer(self.__raw_socket)
+
+        f = self._send_future = asyncio.Future()
+        loop.add_writer(self.__raw_socket, f.set_result, None)
+        f.add_done_callback(callback)
+        return f
+
+    async def aclose(self) -> None:
+        if not self._closing:
+            self._closing = True
+            if self.__raw_socket.fileno() != -1:
+                self.__raw_socket.close()
+
+            if self._receive_future and not self._receive_future.done():
+                self._receive_future.set_result(None)
+            if self._send_future and not self._send_future.done():
+                self._send_future.set_result(None)
+
+
+class UNIXSocketStream(_RawSocketMixin, abc.UNIXSocketStream):
+    async def send_eof(self) -> None:
+        with self._send_guard:
+            self._raw_socket.shutdown(socket.SHUT_WR)
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self._raw_socket.recv(max_bytes)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    if not data:
+                        raise EndOfStream
+
+                    return data
+
+    async def send(self, item: bytes) -> None:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = self._raw_socket.send(view)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    view = view[bytes_sent:]
+
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        loop = get_running_loop()
+        fds = array.array("i")
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, _flags, _addr = self._raw_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        loop = get_running_loop()
+        filenos: list[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    # The ignore can be removed after mypy picks up
+                    # https://github.com/python/typeshed/pull/5545
+                    self._raw_socket.sendmsg(
+                        [message], [(socket.SOL_SOCKET, socket.SCM_RIGHTS, fdarray)]
+                    )
+                    break
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+
+
+class TCPSocketListener(abc.SocketListener):
+    _accept_scope: CancelScope | None = None
+    _closed = False
+
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._loop = cast(asyncio.BaseEventLoop, get_running_loop())
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+    async def accept(self) -> abc.SocketStream:
+        if self._closed:
+            raise ClosedResourceError
+
+        with self._accept_guard:
+            await AsyncIOBackend.checkpoint()
+            with CancelScope() as self._accept_scope:
+                try:
+                    client_sock, _addr = await self._loop.sock_accept(self._raw_socket)
+                except asyncio.CancelledError:
+                    # Workaround for https://bugs.python.org/issue41317
+                    try:
+                        self._loop.remove_reader(self._raw_socket)
+                    except (ValueError, NotImplementedError):
+                        pass
+
+                    if self._closed:
+                        raise ClosedResourceError from None
+
+                    raise
+                finally:
+                    self._accept_scope = None
+
+        client_sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        transport, protocol = await self._loop.connect_accepted_socket(
+            StreamProtocol, client_sock
+        )
+        return SocketStream(transport, protocol)
+
+    async def aclose(self) -> None:
+        if self._closed:
+            return
+
+        self._closed = True
+        if self._accept_scope:
+            # Workaround for https://bugs.python.org/issue41317
+            try:
+                self._loop.remove_reader(self._raw_socket)
+            except (ValueError, NotImplementedError):
+                pass
+
+            self._accept_scope.cancel()
+            await sleep(0)
+
+        self._raw_socket.close()
+
+
+class UNIXSocketListener(abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        self.__raw_socket = raw_socket
+        self._loop = get_running_loop()
+        self._accept_guard = ResourceGuard("accepting connections from")
+        self._closed = False
+
+    async def accept(self) -> abc.SocketStream:
+        await AsyncIOBackend.checkpoint()
+        with self._accept_guard:
+            while True:
+                try:
+                    client_sock, _ = self.__raw_socket.accept()
+                    client_sock.setblocking(False)
+                    return UNIXSocketStream(client_sock)
+                except BlockingIOError:
+                    f: asyncio.Future = asyncio.Future()
+                    self._loop.add_reader(self.__raw_socket, f.set_result, None)
+                    f.add_done_callback(
+                        lambda _: self._loop.remove_reader(self.__raw_socket)
+                    )
+                    await f
+                except OSError as exc:
+                    if self._closed:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+
+    async def aclose(self) -> None:
+        self._closed = True
+        self.__raw_socket.close()
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self.__raw_socket
+
+
+class UDPSocket(abc.UDPSocket):
+    def __init__(
+        self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol
+    ):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def aclose(self) -> None:
+        self._closed = True
+        if not self._transport.is_closing():
+            self._transport.close()
+
+        await self._protocol.closed_event.wait()
+
+    async def receive(self) -> tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            await AsyncIOBackend.checkpoint()
+
+            # If the buffer is empty, ask for more data
+            if not self._protocol.read_queue and not self._transport.is_closing():
+                self._protocol.read_event.clear()
+                await self._protocol.read_event.wait()
+
+            try:
+                return self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                else:
+                    raise BrokenResourceError from None
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            await AsyncIOBackend.checkpoint()
+            await self._protocol.write_event.wait()
+            if self._closed:
+                raise ClosedResourceError
+            elif self._transport.is_closing():
+                raise BrokenResourceError
+            else:
+                self._transport.sendto(*item)
+
+
+class ConnectedUDPSocket(abc.ConnectedUDPSocket):
+    def __init__(
+        self, transport: asyncio.DatagramTransport, protocol: DatagramProtocol
+    ):
+        self._transport = transport
+        self._protocol = protocol
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+        self._closed = False
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._transport.get_extra_info("socket")
+
+    async def aclose(self) -> None:
+        self._closed = True
+        if not self._transport.is_closing():
+            self._transport.close()
+
+        await self._protocol.closed_event.wait()
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            await AsyncIOBackend.checkpoint()
+
+            # If the buffer is empty, ask for more data
+            if not self._protocol.read_queue and not self._transport.is_closing():
+                self._protocol.read_event.clear()
+                await self._protocol.read_event.wait()
+
+            try:
+                packet = self._protocol.read_queue.popleft()
+            except IndexError:
+                if self._closed:
+                    raise ClosedResourceError from None
+                else:
+                    raise BrokenResourceError from None
+
+            return packet[0]
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            await AsyncIOBackend.checkpoint()
+            await self._protocol.write_event.wait()
+            if self._closed:
+                raise ClosedResourceError
+            elif self._transport.is_closing():
+                raise BrokenResourceError
+            else:
+                self._transport.sendto(item)
+
+
+class UNIXDatagramSocket(_RawSocketMixin, abc.UNIXDatagramSocket):
+    async def receive(self) -> UNIXDatagramPacketType:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self._raw_socket.recvfrom(65536)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return data
+
+    async def send(self, item: UNIXDatagramPacketType) -> None:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    self._raw_socket.sendto(*item)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return
+
+
+class ConnectedUNIXDatagramSocket(_RawSocketMixin, abc.ConnectedUNIXDatagramSocket):
+    async def receive(self) -> bytes:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    data = self._raw_socket.recv(65536)
+                except BlockingIOError:
+                    await self._wait_until_readable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return data
+
+    async def send(self, item: bytes) -> None:
+        loop = get_running_loop()
+        await AsyncIOBackend.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    self._raw_socket.send(item)
+                except BlockingIOError:
+                    await self._wait_until_writable(loop)
+                except OSError as exc:
+                    if self._closing:
+                        raise ClosedResourceError from None
+                    else:
+                        raise BrokenResourceError from exc
+                else:
+                    return
+
+
+_read_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("read_events")
+_write_events: RunVar[dict[int, asyncio.Future[bool]]] = RunVar("write_events")
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    __slots__ = ("_event",)
+
+    def __new__(cls) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self._event = asyncio.Event()
+
+    def set(self) -> None:
+        self._event.set()
+
+    def is_set(self) -> bool:
+        return self._event.is_set()
+
+    async def wait(self) -> None:
+        if self.is_set():
+            await AsyncIOBackend.checkpoint()
+        else:
+            await self._event.wait()
+
+    def statistics(self) -> EventStatistics:
+        return EventStatistics(len(self._event._waiters))
+
+
+class Lock(BaseLock):
+    __slots__ = "_fast_acquire", "_owner_task", "_waiters"
+
+    def __new__(cls, *, fast_acquire: bool = False) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False) -> None:
+        self._fast_acquire = fast_acquire
+        self._owner_task: asyncio.Task | None = None
+        self._waiters: deque[tuple[asyncio.Task, asyncio.Future]] = deque()
+
+    async def acquire(self) -> None:
+        task = cast(asyncio.Task, current_task())
+        if self._owner_task is None and not self._waiters:
+            await AsyncIOBackend.checkpoint_if_cancelled()
+            self._owner_task = task
+
+            # Unless on the "fast path", yield control of the event loop so that other
+            # tasks can run too
+            if not self._fast_acquire:
+                try:
+                    await AsyncIOBackend.cancel_shielded_checkpoint()
+                except CancelledError:
+                    self.release()
+                    raise
+
+            return
+
+        if self._owner_task == task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
+        fut: asyncio.Future[None] = asyncio.Future()
+        item = task, fut
+        self._waiters.append(item)
+        try:
+            await fut
+        except CancelledError:
+            if fut.cancelled():
+                try:
+                    self._waiters.remove(item)
+                except ValueError:
+                    pass
+            else:
+                self.release()
+
+            raise
+
+    def acquire_nowait(self) -> None:
+        task = cast(asyncio.Task, current_task())
+        if self._owner_task is None and not self._waiters:
+            self._owner_task = task
+            return
+
+        if self._owner_task is task:
+            raise RuntimeError("Attempted to acquire an already held Lock")
+
+        raise WouldBlock
+
+    def locked(self) -> bool:
+        return self._owner_task is not None
+
+    def release(self) -> None:
+        if self._owner_task != current_task():
+            raise RuntimeError("The current task is not holding this lock")
+
+        # A cancelled waiter that already received ownership removes itself from
+        # _waiters before calling release(); any cancelled waiter still queued here
+        # was cancelled before being woken, so drop it.
+        while self._waiters:
+            task, fut = self._waiters.popleft()
+            if fut.cancelled():
+                continue
+
+            self._owner_task = task
+            fut.set_result(None)
+            return
+
+        self._owner_task = None
+
+    def statistics(self) -> LockStatistics:
+        task_info = AsyncIOTaskInfo(self._owner_task) if self._owner_task else None
+        return LockStatistics(self.locked(), task_info, len(self._waiters))
+
+
+class Semaphore(BaseSemaphore):
+    __slots__ = "_fast_acquire", "_max_value", "_value", "_waiters"
+
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Self:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ):
+        super().__init__(initial_value, max_value=max_value)
+        self._value = initial_value
+        self._max_value = max_value
+        self._fast_acquire = fast_acquire
+        self._waiters: deque[asyncio.Future[None]] = deque()
+
+    async def acquire(self) -> None:
+        if self._value > 0 and not self._waiters:
+            await AsyncIOBackend.checkpoint_if_cancelled()
+            self._value -= 1
+
+            # Unless on the "fast path", yield control of the event loop so that other
+            # tasks can run too
+            if not self._fast_acquire:
+                try:
+                    await AsyncIOBackend.cancel_shielded_checkpoint()
+                except CancelledError:
+                    self.release()
+                    raise
+
+            return
+
+        fut: asyncio.Future[None] = asyncio.Future()
+        self._waiters.append(fut)
+        try:
+            await fut
+        except CancelledError:
+            if fut.cancelled():
+                try:
+                    self._waiters.remove(fut)
+                except ValueError:
+                    pass
+            else:
+                self.release()
+
+            raise
+
+    def acquire_nowait(self) -> None:
+        if self._value == 0:
+            raise WouldBlock
+
+        self._value -= 1
+
+    def release(self) -> None:
+        if self._max_value is not None and self._value == self._max_value:
+            raise ValueError("semaphore released too many times")
+
+        while self._waiters:
+            fut = self._waiters.popleft()
+            if fut.cancelled():
+                continue
+
+            fut.set_result(None)
+            return
+
+        self._value += 1
+
+    @property
+    def value(self) -> int:
+        return self._value
+
+    @property
+    def max_value(self) -> int | None:
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        return SemaphoreStatistics(len(self._waiters))
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    __slots__ = "_borrowers", "_total_tokens", "_wait_queue"
+
+    def __new__(cls, total_tokens: float) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, total_tokens: float):
+        self._total_tokens: float = 0
+        self._borrowers: set[Any] = set()
+        self._wait_queue: OrderedDict[Any, asyncio.Event] = OrderedDict()
+        self.total_tokens = total_tokens
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.release()
+
+    @property
+    def total_tokens(self) -> float:
+        return self._total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        if not isinstance(value, int) and not math.isinf(value):
+            raise TypeError("total_tokens must be an int or math.inf")
+
+        if value < 0:
+            raise ValueError("total_tokens must be >= 0")
+
+        self._total_tokens = value
+
+        # Notify waiting tasks that they have acquired the limiter while
+        # there is spare capacity.
+        while self._wait_queue and len(self._borrowers) < self._total_tokens:
+            borrower, event = self._wait_queue.popitem(last=False)
+            self._borrowers.add(borrower)
+            event.set()
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return len(self._borrowers)
+
+    @property
+    def available_tokens(self) -> float:
+        return self._total_tokens - len(self._borrowers)
+
+    def _notify_next_waiter(self) -> None:
+        """Hand a free token to the next task in line, if any."""
+        if self._wait_queue and len(self._borrowers) < self._total_tokens:
+            borrower, event = self._wait_queue.popitem(last=False)
+            self._borrowers.add(borrower)
+            event.set()
+
+    def acquire_nowait(self) -> None:
+        self.acquire_on_behalf_of_nowait(current_task())
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        if borrower in self._borrowers:
+            raise RuntimeError(
+                "this borrower is already holding one of this CapacityLimiter's tokens"
+            )
+
+        if self._wait_queue or len(self._borrowers) >= self._total_tokens:
+            raise WouldBlock
+
+        self._borrowers.add(borrower)
+
+    async def acquire(self) -> None:
+        return await self.acquire_on_behalf_of(current_task())
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await AsyncIOBackend.checkpoint_if_cancelled()
+        try:
+            self.acquire_on_behalf_of_nowait(borrower)
+        except WouldBlock:
+            event = asyncio.Event()
+            self._wait_queue[borrower] = event
+            try:
+                await event.wait()
+            except BaseException:
+                self._wait_queue.pop(borrower, None)
+                if event.is_set():
+                    self._borrowers.discard(borrower)
+                    self._notify_next_waiter()
+
+                raise
+        else:
+            try:
+                await AsyncIOBackend.cancel_shielded_checkpoint()
+            except BaseException:
+                self.release()
+                raise
+
+    def release(self) -> None:
+        self.release_on_behalf_of(current_task())
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        try:
+            self._borrowers.remove(borrower)
+        except KeyError:
+            raise RuntimeError(
+                "this borrower isn't holding any of this CapacityLimiter's tokens"
+            ) from None
+
+        self._notify_next_waiter()
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        return CapacityLimiterStatistics(
+            self.borrowed_tokens,
+            self.total_tokens,
+            tuple(self._borrowers),
+            len(self._wait_queue),
+        )
+
+
+_default_thread_limiter: RunVar[CapacityLimiter] = RunVar("_default_thread_limiter")
+
+
+#
+# Operating system signals
+#
+
+
+class _SignalReceiver:
+    def __init__(self, signals: tuple[Signals, ...]):
+        self._signals = signals
+        self._loop = get_running_loop()
+        self._signal_queue: deque[Signals] = deque()
+        self._future: asyncio.Future = asyncio.Future()
+        self._handled_signals: set[Signals] = set()
+
+    def _deliver(self, signum: Signals) -> None:
+        self._signal_queue.append(signum)
+        if not self._future.done():
+            self._future.set_result(None)
+
+    def __enter__(self) -> Self:
+        for sig in set(self._signals):
+            self._loop.add_signal_handler(sig, self._deliver, sig)
+            self._handled_signals.add(sig)
+
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        for sig in self._handled_signals:
+            self._loop.remove_signal_handler(sig)
+
+    def __aiter__(self) -> _SignalReceiver:
+        return self
+
+    async def __anext__(self) -> Signals:
+        await AsyncIOBackend.checkpoint()
+        if not self._signal_queue:
+            self._future = asyncio.Future()
+            await self._future
+
+        return self._signal_queue.popleft()
+
+
+#
+# Testing and debugging
+#
+
+
+class AsyncIOTaskInfo(TaskInfo):
+    def __init__(self, task: asyncio.Task):
+        task_state = _task_states.get(task)
+        if task_state is None:
+            parent_id = None
+        else:
+            parent_id = task_state.parent_id
+
+        coro = task.get_coro()
+        assert coro is not None, "created TaskInfo from a completed Task"
+        super().__init__(id(task), parent_id, task.get_name(), coro)
+        self._task = weakref.ref(task)
+
+    def has_pending_cancellation(self) -> bool:
+        if not (task := self._task()):
+            # If the task isn't around anymore, it won't have a pending cancellation
+            return False
+
+        if task._must_cancel or (  # type: ignore[attr-defined]
+            isinstance(task._fut_waiter, asyncio.Future)  # type: ignore[attr-defined]
+            and task._fut_waiter.cancelled()  # type: ignore[attr-defined]
+        ):
+            return True
+
+        if task_state := _task_states.get(task):
+            if cancel_scope := task_state.cancel_scope:
+                return cancel_scope._effectively_cancelled
+
+        return False
+
+
+class TestRunner(abc.TestRunner):
+    _send_stream: MemoryObjectSendStream[tuple[Awaitable[Any], asyncio.Future[Any]]]
+
+    def __init__(
+        self,
+        *,
+        debug: bool | None = None,
+        use_uvloop: bool = False,
+        loop_factory: Callable[[], AbstractEventLoop] | None = None,
+    ) -> None:
+        if use_uvloop and loop_factory is None:
+            if sys.platform != "win32":
+                import uvloop
+
+                loop_factory = uvloop.new_event_loop
+            else:
+                import winloop
+
+                loop_factory = winloop.new_event_loop
+
+        self._runner = Runner(debug=debug, loop_factory=loop_factory)
+        self._exceptions: list[BaseException] = []
+        self._runner_task: asyncio.Task | None = None
+
+    def __enter__(self) -> Self:
+        self._runner.__enter__()
+        self.get_loop().set_exception_handler(self._exception_handler)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._runner.__exit__(exc_type, exc_val, exc_tb)
+
+    def get_loop(self) -> AbstractEventLoop:
+        return self._runner.get_loop()
+
+    def is_running(self) -> bool:
+        try:
+            asyncio.get_running_loop()
+            return True
+        except RuntimeError:
+            return False
+
+    def _exception_handler(
+        self, loop: asyncio.AbstractEventLoop, context: dict[str, Any]
+    ) -> None:
+        if isinstance(context.get("exception"), Exception):
+            self._exceptions.append(context["exception"])
+        else:
+            loop.default_exception_handler(context)
+
+    def _raise_async_exceptions(self) -> None:
+        # Re-raise any exceptions raised in asynchronous callbacks
+        if self._exceptions:
+            exceptions, self._exceptions = self._exceptions, []
+            if len(exceptions) == 1:
+                raise exceptions[0]
+            elif exceptions:
+                raise BaseExceptionGroup(
+                    "Multiple exceptions occurred in asynchronous callbacks", exceptions
+                )
+
+    async def _run_tests_and_fixtures(
+        self,
+        receive_stream: MemoryObjectReceiveStream[
+            tuple[Awaitable[T_Retval], asyncio.Future[T_Retval]]
+        ],
+    ) -> None:
+        from _pytest.outcomes import OutcomeException
+
+        with receive_stream, self._send_stream:
+            async for coro, future in receive_stream:
+                try:
+                    retval = await coro
+                except CancelledError as exc:
+                    if not future.cancelled():
+                        future.cancel(*exc.args)
+
+                    raise
+                except BaseException as exc:
+                    if not future.cancelled():
+                        future.set_exception(exc)
+
+                    if not isinstance(exc, (Exception, OutcomeException)):
+                        raise
+                else:
+                    if not future.cancelled():
+                        future.set_result(retval)
+
+    async def _call_in_runner_task(
+        self,
+        func: Callable[P, Awaitable[T_Retval]],
+        /,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T_Retval:
+        if not self._runner_task:
+            self._send_stream, receive_stream = create_memory_object_stream[
+                tuple[Awaitable[Any], asyncio.Future]
+            ](1)
+            self._runner_task = self.get_loop().create_task(
+                self._run_tests_and_fixtures(receive_stream)
+            )
+
+        coro = func(*args, **kwargs)
+        future: asyncio.Future[T_Retval] = self.get_loop().create_future()
+        self._send_stream.send_nowait((coro, future))
+        return await future
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        asyncgen = fixture_func(**kwargs)
+        fixturevalue: T_Retval = self.get_loop().run_until_complete(
+            self._call_in_runner_task(asyncgen.asend, None)
+        )
+        self._raise_async_exceptions()
+
+        yield fixturevalue
+
+        try:
+            self.get_loop().run_until_complete(
+                self._call_in_runner_task(asyncgen.asend, None)
+            )
+        except StopAsyncIteration:
+            self._raise_async_exceptions()
+        else:
+            self.get_loop().run_until_complete(asyncgen.aclose())
+            raise RuntimeError("Async generator fixture did not stop")
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: dict[str, Any],
+    ) -> T_Retval:
+        retval = self.get_loop().run_until_complete(
+            self._call_in_runner_task(fixture_func, **kwargs)
+        )
+        self._raise_async_exceptions()
+        return retval
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        from _pytest.outcomes import OutcomeException
+
+        try:
+            self.get_loop().run_until_complete(
+                self._call_in_runner_task(test_func, **kwargs)
+            )
+        except Exception as exc:
+            self._exceptions.append(exc)
+        except OutcomeException:
+            raise
+        except BaseException:
+            # A BaseException (e.g. KeyboardInterrupt, SystemExit) interrupted the event loop before
+            # the test completed. Cancel _runner_task so it does not resume when the event
+            # loop is re-entered during async generator fixture teardown.
+            if self._runner_task is not None and not self._runner_task.done():
+                self._runner_task.cancel()
+                self._send_stream.close()
+                try:
+                    self.get_loop().run_until_complete(self._runner_task)
+                except CancelledError:
+                    pass
+                finally:
+                    self._runner_task = None
+            raise
+        self._raise_async_exceptions()
+
+
+class _ProcessStreamProtocol(asyncio.subprocess.SubprocessStreamProtocol):
+    """
+    A subprocess protocol that allows us to be notified of ``process_exited``
+
+    asyncio's own ``Process.wait()`` only resolves once every pipe transport has
+    disconnected so to get same semantics as on trio and uvloop we need this.
+    """
+
+    def __init__(self) -> None:
+        # Match the standard factory for asyncio.create_process
+        super().__init__(limit=2**16, loop=asyncio.get_running_loop())
+        self.exited = asyncio.Event()
+
+    def process_exited(self) -> None:
+        super().process_exited()
+        self.exited.set()
+
+
+class AsyncIOBackend(AsyncBackend):
+    @classmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        @wraps(func)
+        async def wrapper() -> T_Retval:
+            task = cast(asyncio.Task, current_task())
+            task.set_name(get_callable_name(func))
+            _task_states[task] = TaskState(None, None)
+
+            try:
+                return await func(*args)
+            finally:
+                del _task_states[task]
+
+        debug = options.get("debug", None)
+        loop_factory = options.get("loop_factory", None)
+        if loop_factory is None and options.get("use_uvloop", False):
+            if sys.platform != "win32":
+                import uvloop
+
+                loop_factory = uvloop.new_event_loop
+            else:
+                import winloop
+
+                loop_factory = winloop.new_event_loop
+
+        with Runner(debug=debug, loop_factory=loop_factory) as runner:
+            return runner.run(wrapper())
+
+    @classmethod
+    def current_token(cls) -> object:
+        return get_running_loop()
+
+    @classmethod
+    def current_time(cls) -> float:
+        return get_running_loop().time()
+
+    @classmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        return CancelledError
+
+    @classmethod
+    async def checkpoint(cls) -> None:
+        await sleep(0)
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        task = current_task()
+        if task is None:
+            return
+
+        try:
+            cancel_scope = _task_states[task].cancel_scope
+        except KeyError:
+            return
+
+        while cancel_scope:
+            if cancel_scope.cancel_called:
+                await sleep(0)
+            elif cancel_scope.shield:
+                break
+            else:
+                cancel_scope = cancel_scope._parent_scope
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        with CancelScope(shield=True):
+            await sleep(0)
+
+    @classmethod
+    async def sleep(cls, delay: float) -> None:
+        await sleep(delay)
+
+    @classmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> CancelScope:
+        return CancelScope(deadline=deadline, shield=shield)
+
+    @classmethod
+    def current_effective_deadline(cls) -> float:
+        if (task := current_task()) is None:
+            return math.inf
+
+        try:
+            cancel_scope = _task_states[task].cancel_scope
+        except KeyError:
+            return math.inf
+
+        deadline = math.inf
+        while cancel_scope:
+            deadline = min(deadline, cancel_scope.deadline)
+            if cancel_scope._cancel_called:
+                deadline = -math.inf
+                break
+            elif cancel_scope.shield:
+                break
+            else:
+                cancel_scope = cancel_scope._parent_scope
+
+        return deadline
+
+    @classmethod
+    def create_task_group(cls) -> abc.TaskGroup:
+        return TaskGroup()
+
+    @classmethod
+    def create_event(cls) -> BaseEvent:
+        return Event()
+
+    @classmethod
+    def create_lock(cls, *, fast_acquire: bool) -> BaseLock:
+        return Lock(fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> BaseSemaphore:
+        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> BaseCapacityLimiter:
+        return CapacityLimiter(total_tokens)
+
+    @classmethod
+    async def run_sync_in_worker_thread(  # type: ignore[return]
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: BaseCapacityLimiter | None = None,
+    ) -> T_Retval:
+        await cls.checkpoint()
+
+        # If this is the first run in this event loop thread, set up the necessary
+        # variables
+        try:
+            idle_workers = _threadpool_idle_workers.get()
+            workers = _threadpool_workers.get()
+        except LookupError:
+            idle_workers = deque()
+            workers = set()
+            _threadpool_idle_workers.set(idle_workers)
+            _threadpool_workers.set(workers)
+
+        async with limiter or cls.current_default_thread_limiter():
+            with CancelScope(shield=not abandon_on_cancel) as scope:
+                future = asyncio.Future[T_Retval]()
+                root_task = find_root_task()
+                if not idle_workers:
+                    worker = WorkerThread(root_task, workers, idle_workers)
+                    worker.start()
+                    workers.add(worker)
+                    root_task.add_done_callback(worker.stop, context=Context())
+                else:
+                    worker = idle_workers.pop()
+
+                    # Prune any other workers that have been idle for MAX_IDLE_TIME
+                    # seconds or longer
+                    now = cls.current_time()
+                    while idle_workers:
+                        if (
+                            now - idle_workers[0].idle_since
+                            < WorkerThread.MAX_IDLE_TIME
+                        ):
+                            break
+
+                        expired_worker = idle_workers.popleft()
+                        expired_worker.root_task.remove_done_callback(
+                            expired_worker.stop
+                        )
+                        expired_worker.stop()
+
+                context = copy_context()
+                context.run(set_current_async_library, None)
+                if abandon_on_cancel or scope._parent_scope is None:
+                    worker_scope = scope
+                else:
+                    worker_scope = scope._parent_scope
+
+                worker.queue.put_nowait((context, func, args, future, worker_scope))
+                return await future
+
+    @classmethod
+    def check_cancelled(cls) -> None:
+        scope: CancelScope | None = threadlocals.current_cancel_scope
+        while scope is not None:
+            if scope.cancel_called:
+                raise CancelledError(f"Cancelled via cancel scope {id(scope):x}")
+
+            if scope.shield:
+                return
+
+            scope = scope._parent_scope
+
+    @classmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_co:
+        async def task_wrapper() -> T_co:
+            __tracebackhide__ = True
+            if scope is not None:
+                task = cast(asyncio.Task, current_task())
+                _task_states[task] = TaskState(None, scope)
+                scope._tasks.add(task)
+            try:
+                return await func(*args)
+            except CancelledError as exc:
+                raise concurrent.futures.CancelledError(str(exc)) from None
+            finally:
+                if scope is not None:
+                    scope._tasks.discard(task)
+
+        loop = cast(
+            "AbstractEventLoop", token or threadlocals.current_token.native_token
+        )
+        if loop.is_closed():
+            raise RunFinishedError
+
+        context = copy_context()
+        context.run(set_current_async_library, "asyncio")
+        scope = getattr(threadlocals, "current_cancel_scope", None)
+        f: concurrent.futures.Future[T_co] = context.run(
+            asyncio.run_coroutine_threadsafe, task_wrapper(), loop=loop
+        )
+        return f.result()
+
+    @classmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        @wraps(func)
+        def wrapper() -> None:
+            try:
+                set_current_async_library("asyncio")
+                f.set_result(func(*args))
+            except BaseException as exc:
+                f.set_exception(exc)
+                if not isinstance(exc, Exception):
+                    raise
+
+        loop = cast(
+            "AbstractEventLoop", token or threadlocals.current_token.native_token
+        )
+        if loop.is_closed():
+            raise RunFinishedError
+
+        f: concurrent.futures.Future[T_Retval] = Future()
+        loop.call_soon_threadsafe(wrapper)
+        return f.result()
+
+    @classmethod
+    async def open_process(
+        cls,
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
+        *,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        **kwargs: Any,
+    ) -> Process:
+        await cls.checkpoint()
+        if isinstance(command, PathLike):
+            command = os.fspath(command)
+
+        # Use loop.subprocess_shell()/subprocess_exec() rather than their
+        # asyncio.create_subprocess_*() counterparts to get access to
+        # transport/protocol.
+        loop = asyncio.get_running_loop()
+        if isinstance(command, (str, bytes)):
+            transport, protocol = await loop.subprocess_shell(
+                _ProcessStreamProtocol,
+                command,
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                **kwargs,
+            )
+        else:
+            transport, protocol = await loop.subprocess_exec(
+                _ProcessStreamProtocol,
+                *command,
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                **kwargs,
+            )
+
+        process = asyncio.subprocess.Process(transport, protocol, loop)
+        stdin_stream = StreamWriterWrapper(process.stdin) if process.stdin else None
+        stdout_stream = StreamReaderWrapper(process.stdout) if process.stdout else None
+        stderr_stream = StreamReaderWrapper(process.stderr) if process.stderr else None
+        return Process(
+            process,
+            stdin_stream,
+            stdout_stream,
+            stderr_stream,
+            protocol.exited,
+            transport,
+        )
+
+    @classmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None:
+        create_task(
+            _shutdown_process_pool_on_exit(workers),
+            name="AnyIO process pool shutdown task",
+        )
+        find_root_task().add_done_callback(
+            partial(_forcibly_shutdown_process_pool_on_exit, workers)  # type:ignore[arg-type]
+        )
+
+    @classmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> abc.SocketStream:
+        transport, protocol = cast(
+            tuple[asyncio.Transport, StreamProtocol],
+            await get_running_loop().create_connection(
+                StreamProtocol, host, port, local_addr=local_address
+            ),
+        )
+        transport.pause_reading()
+        return SocketStream(transport, protocol)
+
+    @classmethod
+    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
+        await cls.checkpoint()
+        loop = get_running_loop()
+        raw_socket = socket.socket(socket.AF_UNIX)
+        raw_socket.setblocking(False)
+        while True:
+            try:
+                raw_socket.connect(path)
+            except BlockingIOError:
+                f: asyncio.Future = asyncio.Future()
+                loop.add_writer(raw_socket, f.set_result, None)
+                f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
+                await f
+            except BaseException:
+                raw_socket.close()
+                raise
+            else:
+                return UNIXSocketStream(raw_socket)
+
+    @classmethod
+    def create_tcp_listener(cls, sock: socket.socket) -> SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    def create_unix_listener(cls, sock: socket.socket) -> SocketListener:
+        return UNIXSocketListener(sock)
+
+    @classmethod
+    async def create_udp_socket(
+        cls,
+        family: AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        transport, protocol = await get_running_loop().create_datagram_endpoint(
+            DatagramProtocol,
+            local_addr=local_address,
+            remote_addr=remote_address,
+            family=family,
+            reuse_port=reuse_port,
+        )
+        if protocol.exception:
+            transport.close()
+            raise protocol.exception
+
+        if not remote_address:
+            return UDPSocket(transport, protocol)
+        else:
+            return ConnectedUDPSocket(transport, protocol)
+
+    @classmethod
+    async def create_unix_datagram_socket(  # type: ignore[override]
+        cls, raw_socket: socket.socket, remote_path: str | bytes | None
+    ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket:
+        await cls.checkpoint()
+        loop = get_running_loop()
+
+        if remote_path:
+            while True:
+                try:
+                    raw_socket.connect(remote_path)
+                except BlockingIOError:
+                    f: asyncio.Future = asyncio.Future()
+                    loop.add_writer(raw_socket, f.set_result, None)
+                    f.add_done_callback(lambda _: loop.remove_writer(raw_socket))
+                    await f
+                except BaseException:
+                    raw_socket.close()
+                    raise
+                else:
+                    return ConnectedUNIXDatagramSocket(raw_socket)
+        else:
+            return UNIXDatagramSocket(raw_socket)
+
+    @classmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> Sequence[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes],
+        ]
+    ]:
+        return await get_running_loop().getaddrinfo(
+            host, port, family=family, type=type, proto=proto, flags=flags
+        )
+
+    @classmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        return await get_running_loop().getnameinfo(sockaddr, flags)
+
+    @classmethod
+    async def wait_readable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            read_events = _read_events.get()
+        except LookupError:
+            read_events = {}
+            _read_events.set(read_events)
+
+        fd = obj if isinstance(obj, int) else obj.fileno()
+        if read_events.get(fd):
+            raise BusyResourceError("reading from")
+
+        loop = get_running_loop()
+        fut: asyncio.Future[bool] = loop.create_future()
+
+        def cb() -> None:
+            try:
+                del read_events[fd]
+            except KeyError:
+                pass
+            else:
+                remove_reader(fd)
+
+            try:
+                fut.set_result(True)
+            except asyncio.InvalidStateError:
+                pass
+
+        try:
+            loop.add_reader(fd, cb)
+        except NotImplementedError:
+            from anyio._core._asyncio_selector_thread import get_selector
+
+            selector = get_selector()
+            selector.add_reader(fd, cb)
+            remove_reader = selector.remove_reader
+        else:
+            remove_reader = loop.remove_reader
+
+        read_events[fd] = fut
+        try:
+            success = await fut
+        finally:
+            try:
+                del read_events[fd]
+            except KeyError:
+                pass
+            else:
+                remove_reader(fd)
+
+        if not success:
+            raise ClosedResourceError
+
+    @classmethod
+    async def wait_writable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            write_events = _write_events.get()
+        except LookupError:
+            write_events = {}
+            _write_events.set(write_events)
+
+        fd = obj if isinstance(obj, int) else obj.fileno()
+        if write_events.get(fd):
+            raise BusyResourceError("writing to")
+
+        loop = get_running_loop()
+        fut: asyncio.Future[bool] = loop.create_future()
+
+        def cb() -> None:
+            try:
+                del write_events[fd]
+            except KeyError:
+                pass
+            else:
+                remove_writer(fd)
+
+            try:
+                fut.set_result(True)
+            except asyncio.InvalidStateError:
+                pass
+
+        try:
+            loop.add_writer(fd, cb)
+        except NotImplementedError:
+            from anyio._core._asyncio_selector_thread import get_selector
+
+            selector = get_selector()
+            selector.add_writer(fd, cb)
+            remove_writer = selector.remove_writer
+        else:
+            remove_writer = loop.remove_writer
+
+        write_events[fd] = fut
+        try:
+            success = await fut
+        finally:
+            try:
+                del write_events[fd]
+            except KeyError:
+                pass
+            else:
+                remove_writer(fd)
+
+        if not success:
+            raise ClosedResourceError
+
+    @classmethod
+    def notify_closing(cls, obj: FileDescriptorLike) -> None:
+        fd = obj if isinstance(obj, int) else obj.fileno()
+        loop = get_running_loop()
+
+        try:
+            write_events = _write_events.get()
+        except LookupError:
+            pass
+        else:
+            try:
+                fut = write_events.pop(fd)
+            except KeyError:
+                pass
+            else:
+                try:
+                    fut.set_result(False)
+                except asyncio.InvalidStateError:
+                    pass
+
+                try:
+                    loop.remove_writer(fd)
+                except NotImplementedError:
+                    from anyio._core._asyncio_selector_thread import get_selector
+
+                    get_selector().remove_writer(fd)
+
+        try:
+            read_events = _read_events.get()
+        except LookupError:
+            pass
+        else:
+            try:
+                fut = read_events.pop(fd)
+            except KeyError:
+                pass
+            else:
+                try:
+                    fut.set_result(False)
+                except asyncio.InvalidStateError:
+                    pass
+
+                try:
+                    loop.remove_reader(fd)
+                except NotImplementedError:
+                    from anyio._core._asyncio_selector_thread import get_selector
+
+                    get_selector().remove_reader(fd)
+
+    @classmethod
+    async def wrap_listener_socket(cls, sock: socket.socket) -> SocketListener:
+        if hasattr(socket, "AF_UNIX") and sock.family == socket.AF_UNIX:
+            return UNIXSocketListener(sock)
+
+        return TCPSocketListener(sock)
+
+    @classmethod
+    async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream:
+        transport, protocol = await get_running_loop().create_connection(
+            StreamProtocol, sock=sock
+        )
+        return SocketStream(transport, protocol)
+
+    @classmethod
+    async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream:
+        return UNIXSocketStream(sock)
+
+    @classmethod
+    async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket:
+        transport, protocol = await get_running_loop().create_datagram_endpoint(
+            DatagramProtocol, sock=sock
+        )
+        return UDPSocket(transport, protocol)
+
+    @classmethod
+    async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket:
+        transport, protocol = await get_running_loop().create_datagram_endpoint(
+            DatagramProtocol, sock=sock
+        )
+        return ConnectedUDPSocket(transport, protocol)
+
+    @classmethod
+    async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket:
+        return UNIXDatagramSocket(sock)
+
+    @classmethod
+    async def wrap_connected_unix_datagram_socket(
+        cls, sock: socket.socket
+    ) -> ConnectedUNIXDatagramSocket:
+        return ConnectedUNIXDatagramSocket(sock)
+
+    @classmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        try:
+            return _default_thread_limiter.get()
+        except LookupError:
+            limiter = CapacityLimiter(40)
+            _default_thread_limiter.set(limiter)
+            return limiter
+
+    @classmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> AbstractContextManager[AsyncIterator[Signals]]:
+        return _SignalReceiver(signals)
+
+    @classmethod
+    def get_current_task(cls) -> TaskInfo:
+        return AsyncIOTaskInfo(current_task())  # type: ignore[arg-type]
+
+    @classmethod
+    def get_running_tasks(cls) -> Sequence[TaskInfo]:
+        return [AsyncIOTaskInfo(task) for task in all_tasks() if not task.done()]
+
+    @classmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        await cls.checkpoint()
+        this_task = current_task()
+        while True:
+            for task in all_tasks():
+                if task is this_task:
+                    continue
+
+                waiter = task._fut_waiter  # type: ignore[attr-defined]
+                if waiter is None or waiter.done():
+                    await sleep(0.1)
+                    break
+            else:
+                return
+
+    @classmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        return TestRunner(**options)
+
+
+backend_class = AsyncIOBackend
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_trio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_trio.py
new file mode 100644
index 0000000000000000000000000000000000000000..2e67786e81a6f41976ad2467f818a205ba5637e9
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_backends/_trio.py
@@ -0,0 +1,1473 @@
+from __future__ import annotations
+
+import array
+import math
+import os
+import socket
+import sys
+import types
+import weakref
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Collection,
+    Coroutine,
+    Iterable,
+    Sequence,
+)
+from contextlib import AbstractContextManager
+from contextvars import Context
+from dataclasses import dataclass
+from functools import partial, wraps
+from io import IOBase
+from os import PathLike
+from signal import Signals
+from socket import AddressFamily, SocketKind
+from types import TracebackType
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Literal,
+    NoReturn,
+    ParamSpec,
+    TypeVar,
+    cast,
+    overload,
+)
+
+import trio.from_thread
+import trio.lowlevel
+from outcome import Error, Outcome, Value
+from trio.lowlevel import (
+    current_root_task,
+    current_task,
+    notify_closing,
+    wait_readable,
+    wait_writable,
+)
+from trio.socket import SocketType as TrioSocketType
+from trio.to_thread import run_sync
+
+from .. import (
+    CapacityLimiterStatistics,
+    EventStatistics,
+    LockStatistics,
+    RunFinishedError,
+    TaskInfo,
+    WouldBlock,
+    abc,
+)
+from .._core._eventloop import claim_worker_thread
+from .._core._exceptions import (
+    BrokenResourceError,
+    BusyResourceError,
+    ClosedResourceError,
+    EndOfStream,
+)
+from .._core._sockets import convert_ipv6_sockaddr
+from .._core._streams import create_memory_object_stream
+from .._core._synchronization import (
+    CapacityLimiter as BaseCapacityLimiter,
+)
+from .._core._synchronization import Event as BaseEvent
+from .._core._synchronization import Lock as BaseLock
+from .._core._synchronization import (
+    ResourceGuard,
+    SemaphoreStatistics,
+)
+from .._core._synchronization import Semaphore as BaseSemaphore
+from .._core._tasks import CancelScope as BaseCancelScope
+from .._core._tasks import TaskHandle
+from ..abc import IPSockAddrType, UDPPacketType, UNIXDatagramPacketType
+from ..abc._eventloop import AsyncBackend, StrOrBytesPath
+from ..abc._tasks import T_contra, call_for_coroutine, get_callable_name, get_coro_name
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+    from ..streams.memory import MemoryObjectSendStream
+
+if sys.version_info < (3, 15):
+    from typing_extensions import sentinel
+
+if sys.version_info >= (3, 11):
+    from typing import Self, TypeVarTuple, Unpack
+else:
+    from exceptiongroup import BaseExceptionGroup
+    from typing_extensions import Self, TypeVarTuple, Unpack
+
+T = TypeVar("T")
+T_Retval = TypeVar("T_Retval")
+T_co = TypeVar("T_co", covariant=True)
+T_SockAddr = TypeVar("T_SockAddr", str, IPSockAddrType)
+PosArgsT = TypeVarTuple("PosArgsT")
+P = ParamSpec("P")
+
+
+def ensure_returns_coro(
+    func: Callable[P, Awaitable[T_Retval]],
+) -> Callable[P, Coroutine[Any, Any, T_Retval]]:
+    @wraps(func)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> Coroutine[Any, Any, T_Retval]:
+        awaitable = func(*args, **kwargs)
+        # Check the common case first.
+        if isinstance(awaitable, Coroutine):
+            return awaitable
+        elif not isinstance(awaitable, Awaitable):
+            # The user violated the type annotations. Still, we should pass this on to
+            # Trio so it can raise with an appropriate message.
+            return awaitable
+        else:
+
+            @wraps(func)
+            async def inner_wrapper() -> T_Retval:
+                return await awaitable
+
+            return inner_wrapper()
+
+    return wrapper
+
+
+#
+# Event loop
+#
+
+RunVar = trio.lowlevel.RunVar
+
+
+#
+# Timeouts and cancellation
+#
+
+
+class CancelScope(BaseCancelScope):
+    __slots__ = ("__original",)
+
+    def __new__(
+        cls, original: trio.CancelScope | None = None, **kwargs: object
+    ) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, original: trio.CancelScope | None = None, **kwargs: Any) -> None:
+        self.__original = original or trio.CancelScope(**kwargs)
+
+    def __enter__(self) -> Self:
+        self.__original.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        return self.__original.__exit__(exc_type, exc_val, exc_tb)
+
+    def cancel(self, reason: str | None = None) -> None:
+        self.__original.cancel(reason)
+
+    @property
+    def deadline(self) -> float:
+        return self.__original.deadline
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        self.__original.deadline = value
+
+    @property
+    def cancel_called(self) -> bool:
+        return self.__original.cancel_called
+
+    @property
+    def cancelled_caught(self) -> bool:
+        return self.__original.cancelled_caught
+
+    @property
+    def shield(self) -> bool:
+        return self.__original.shield
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        self.__original.shield = value
+
+
+#
+# Task groups
+#
+
+empty_start_value = sentinel("empty_start_value")
+
+
+class _TrioTaskStatus(abc.TaskStatus[T_contra], Generic[T_contra]):
+    early_start_value: T_contra | object = empty_start_value
+    real_task_status: trio.TaskStatus[T_contra | None] | None = None
+
+    def started(self, value: T_contra | None = None) -> None:
+        if self.real_task_status is None:
+            if self.early_start_value is not empty_start_value:
+                raise RuntimeError("called 'started' twice on the same task status")
+
+            self.early_start_value = value
+        else:
+            self.real_task_status.started(value)
+
+
+class TaskGroup(abc.TaskGroup):
+    def __init__(self) -> None:
+        self._entered = False
+        self._active = False
+        self._nursery_manager = trio.open_nursery(strict_exception_groups=True)
+        self.cancel_scope = None  # type: ignore[assignment]
+
+    async def __aenter__(self) -> Self:
+        if self._entered:
+            raise RuntimeError("TaskGroup cannot be entered more than once")
+
+        self._entered = True
+        self._active = True
+        self._nursery = await self._nursery_manager.__aenter__()
+        self.cancel_scope = CancelScope(self._nursery.cancel_scope)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        try:
+            # trio.Nursery.__exit__ returns bool; .open_nursery has wrong type
+            return await self._nursery_manager.__aexit__(exc_type, exc_val, exc_tb)  # type: ignore[return-value]
+        except BaseExceptionGroup as exc:
+            if not exc.split(trio.Cancelled)[1]:
+                raise trio.Cancelled._create() from exc
+
+            raise
+        finally:
+            del exc_val, exc_tb
+            self._active = False
+
+    def _check_active(self, coro: Coroutine | None = None) -> None:
+        if not self._active:
+            if coro is not None:
+                coro.close()
+
+            raise RuntimeError(
+                "This task group is not active; no new tasks can be started."
+            )
+
+    def create_task(
+        self,
+        coro: Coroutine[Any, Any, T_co],
+        *,
+        name: object = None,
+        context: Context | None = None,
+    ) -> TaskHandle[T_co]:
+        if not isinstance(coro, Coroutine):
+            raise TypeError(f"expected a coroutine, got {coro.__class__.__qualname__}")
+
+        self._check_active(coro)
+        final_name = get_coro_name(coro, name)
+        handle = TaskHandle(coro, final_name)
+        if context is not None:
+            context.run(
+                partial(self._nursery.start_soon, handle._run_coro, name=handle.name)
+            )
+        else:
+            self._nursery.start_soon(handle._run_coro, name=handle.name)
+
+        return handle
+
+    async def start(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+        return_handle: Literal[False, True] = False,
+    ) -> Any:
+        handle: TaskHandle[T_co]
+
+        async def run_coro_with_task_status(
+            *, task_status: trio.TaskStatus[Any]
+        ) -> None:
+            nonlocal handle
+            wrapper_task_status = _TrioTaskStatus()
+            coro = call_for_coroutine(func, args, task_status=wrapper_task_status)
+            if wrapper_task_status.early_start_value is not empty_start_value:
+                task_status.started(wrapper_task_status.early_start_value)
+            else:
+                wrapper_task_status.real_task_status = task_status
+
+            handle = TaskHandle(coro, final_name)
+            await handle._run_coro()
+
+        self._check_active()
+        final_name = get_callable_name(func, name)
+        start_value = await self._nursery.start(
+            run_coro_with_task_status, name=final_name
+        )
+        if return_handle:
+            handle._start_value = start_value
+            return handle
+        else:
+            return start_value
+
+
+#
+# Subprocesses
+#
+
+
+@dataclass(eq=False)
+class ReceiveStreamWrapper(abc.ByteReceiveStream):
+    _stream: trio.abc.ReceiveStream
+
+    async def receive(self, max_bytes: int | None = None) -> bytes:
+        if max_bytes is not None and max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        try:
+            data = await self._stream.receive_some(max_bytes)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+        if data:
+            return bytes(data)
+        else:
+            raise EndOfStream
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class SendStreamWrapper(abc.ByteSendStream):
+    _stream: trio.abc.SendStream
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await self._stream.send_all(item)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError from exc.__cause__
+        except trio.BrokenResourceError as exc:
+            raise BrokenResourceError from exc.__cause__
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+
+@dataclass(eq=False)
+class Process(abc.Process):
+    _process: trio.Process
+    _stdin: abc.ByteSendStream | None
+    _stdout: abc.ByteReceiveStream | None
+    _stderr: abc.ByteReceiveStream | None
+
+    async def aclose(self) -> None:
+        with CancelScope(shield=True):
+            if self._stdin:
+                await self._stdin.aclose()
+            if self._stdout:
+                await self._stdout.aclose()
+            if self._stderr:
+                await self._stderr.aclose()
+
+        try:
+            await self.wait()
+        except BaseException:
+            self.kill()
+            with CancelScope(shield=True):
+                await self.wait()
+            raise
+
+    async def wait(self) -> int:
+        return await self._process.wait()
+
+    def terminate(self) -> None:
+        self._process.terminate()
+
+    def kill(self) -> None:
+        self._process.kill()
+
+    def send_signal(self, signal: Signals) -> None:
+        self._process.send_signal(signal)
+
+    @property
+    def pid(self) -> int:
+        return self._process.pid
+
+    @property
+    def returncode(self) -> int | None:
+        return self._process.returncode
+
+    @property
+    def stdin(self) -> abc.ByteSendStream | None:
+        return self._stdin
+
+    @property
+    def stdout(self) -> abc.ByteReceiveStream | None:
+        return self._stdout
+
+    @property
+    def stderr(self) -> abc.ByteReceiveStream | None:
+        return self._stderr
+
+
+class _ProcessPoolShutdownInstrument(trio.abc.Instrument):
+    def after_run(self) -> None:
+        super().after_run()
+
+
+current_default_worker_process_limiter: trio.lowlevel.RunVar = RunVar(
+    "current_default_worker_process_limiter"
+)
+
+
+async def _shutdown_process_pool(workers: set[abc.Process]) -> None:
+    try:
+        await trio.sleep(math.inf)
+    except trio.Cancelled:
+        for process in workers:
+            if process.returncode is None:
+                process.kill()
+
+        with CancelScope(shield=True):
+            for process in workers:
+                await process.aclose()
+
+
+#
+# Sockets and networking
+#
+
+
+class _TrioSocketMixin(Generic[T_SockAddr]):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        self._trio_socket = trio_socket
+        self._closed = False
+
+    def _check_closed(self) -> None:
+        if self._closed:
+            raise ClosedResourceError
+        if self._trio_socket.fileno() < 0:
+            raise BrokenResourceError
+
+    @property
+    def _raw_socket(self) -> socket.socket:
+        return self._trio_socket._sock  # type: ignore[attr-defined]
+
+    async def aclose(self) -> None:
+        if self._trio_socket.fileno() >= 0:
+            self._closed = True
+            self._trio_socket.close()
+
+    def _convert_socket_error(self, exc: BaseException) -> NoReturn:
+        if isinstance(exc, trio.ClosedResourceError):
+            raise ClosedResourceError from exc
+        elif self._trio_socket.fileno() < 0 and self._closed:
+            raise ClosedResourceError from None
+        elif isinstance(exc, OSError):
+            raise BrokenResourceError from exc
+        else:
+            raise exc
+
+
+class SocketStream(_TrioSocketMixin, abc.SocketStream):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        with self._receive_guard:
+            try:
+                data = await self._trio_socket.recv(max_bytes)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+            if data:
+                return data
+            else:
+                raise EndOfStream
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            view = memoryview(item)
+            while view:
+                try:
+                    bytes_sent = await self._trio_socket.send(view)
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+                view = view[bytes_sent:]
+
+    async def send_eof(self) -> None:
+        self._trio_socket.shutdown(socket.SHUT_WR)
+
+
+class UNIXSocketStream(SocketStream, abc.UNIXSocketStream):
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
+        if not isinstance(msglen, int) or msglen < 0:
+            raise ValueError("msglen must be a non-negative integer")
+        if not isinstance(maxfds, int) or maxfds < 1:
+            raise ValueError("maxfds must be a positive integer")
+
+        fds = array.array("i")
+        await trio.lowlevel.checkpoint()
+        with self._receive_guard:
+            while True:
+                try:
+                    message, ancdata, _flags, _addr = await self._trio_socket.recvmsg(
+                        msglen, socket.CMSG_LEN(maxfds * fds.itemsize)
+                    )
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+                else:
+                    if not message and not ancdata:
+                        raise EndOfStream
+
+                    break
+
+        for cmsg_level, cmsg_type, cmsg_data in ancdata:
+            if cmsg_level != socket.SOL_SOCKET or cmsg_type != socket.SCM_RIGHTS:
+                raise RuntimeError(
+                    f"Received unexpected ancillary data; message = {message!r}, "
+                    f"cmsg_level = {cmsg_level}, cmsg_type = {cmsg_type}"
+                )
+
+            fds.frombytes(cmsg_data[: len(cmsg_data) - (len(cmsg_data) % fds.itemsize)])
+
+        return message, list(fds)
+
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
+        if not message:
+            raise ValueError("message must not be empty")
+        if not fds:
+            raise ValueError("fds must not be empty")
+
+        filenos: list[int] = []
+        for fd in fds:
+            if isinstance(fd, int):
+                filenos.append(fd)
+            elif isinstance(fd, IOBase):
+                filenos.append(fd.fileno())
+
+        fdarray = array.array("i", filenos)
+        await trio.lowlevel.checkpoint()
+        with self._send_guard:
+            while True:
+                try:
+                    await self._trio_socket.sendmsg(
+                        [message],
+                        [
+                            (
+                                socket.SOL_SOCKET,
+                                socket.SCM_RIGHTS,
+                                fdarray,
+                            )
+                        ],
+                    )
+                    break
+                except BaseException as exc:
+                    self._convert_socket_error(exc)
+
+
+class TCPSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> SocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SocketStream(trio_socket)
+
+
+class UNIXSocketListener(_TrioSocketMixin, abc.SocketListener):
+    def __init__(self, raw_socket: socket.socket):
+        super().__init__(trio.socket.from_stdlib_socket(raw_socket))
+        self._accept_guard = ResourceGuard("accepting connections from")
+
+    async def accept(self) -> UNIXSocketStream:
+        with self._accept_guard:
+            try:
+                trio_socket, _addr = await self._trio_socket.accept()
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+        return UNIXSocketStream(trio_socket)
+
+
+class UDPSocket(_TrioSocketMixin[IPSockAddrType], abc.UDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> tuple[bytes, IPSockAddrType]:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, convert_ipv6_sockaddr(addr)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UDPPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUDPSocket(_TrioSocketMixin[IPSockAddrType], abc.ConnectedUDPSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class UNIXDatagramSocket(_TrioSocketMixin[str], abc.UNIXDatagramSocket):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> UNIXDatagramPacketType:
+        with self._receive_guard:
+            try:
+                data, addr = await self._trio_socket.recvfrom(65536)
+                return data, addr
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: UNIXDatagramPacketType) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.sendto(*item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+class ConnectedUNIXDatagramSocket(
+    _TrioSocketMixin[str], abc.ConnectedUNIXDatagramSocket
+):
+    def __init__(self, trio_socket: TrioSocketType) -> None:
+        super().__init__(trio_socket)
+        self._receive_guard = ResourceGuard("reading from")
+        self._send_guard = ResourceGuard("writing to")
+
+    async def receive(self) -> bytes:
+        with self._receive_guard:
+            try:
+                return await self._trio_socket.recv(65536)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+    async def send(self, item: bytes) -> None:
+        with self._send_guard:
+            try:
+                await self._trio_socket.send(item)
+            except BaseException as exc:
+                self._convert_socket_error(exc)
+
+
+#
+# Synchronization
+#
+
+
+class Event(BaseEvent):
+    __slots__ = ("__original",)
+
+    def __new__(cls) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self.__original = trio.Event()
+
+    def is_set(self) -> bool:
+        return self.__original.is_set()
+
+    async def wait(self) -> None:
+        return await self.__original.wait()
+
+    def statistics(self) -> EventStatistics:
+        orig_statistics = self.__original.statistics()
+        return EventStatistics(tasks_waiting=orig_statistics.tasks_waiting)
+
+    def set(self) -> None:
+        self.__original.set()
+
+
+class Lock(BaseLock):
+    __slots__ = "__original", "_fast_acquire"
+
+    def __new__(cls, *, fast_acquire: bool = False) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False) -> None:
+        self._fast_acquire = fast_acquire
+        self.__original = trio.Lock()
+
+    @staticmethod
+    def _convert_runtime_error_msg(exc: RuntimeError) -> None:
+        if exc.args == ("attempt to re-acquire an already held Lock",):
+            exc.args = ("Attempted to acquire an already held Lock",)
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            try:
+                await self.__original.acquire()
+            except RuntimeError as exc:
+                self._convert_runtime_error_msg(exc)
+                raise
+
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+        except RuntimeError as exc:
+            self._convert_runtime_error_msg(exc)
+            raise
+
+    def locked(self) -> bool:
+        return self.__original.locked()
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> LockStatistics:
+        orig_statistics = self.__original.statistics()
+        owner = TrioTaskInfo(orig_statistics.owner) if orig_statistics.owner else None
+        return LockStatistics(
+            orig_statistics.locked, owner, orig_statistics.tasks_waiting
+        )
+
+
+class Semaphore(BaseSemaphore):
+    __slots__ = ("__original",)
+
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Self:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> None:
+        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+        self.__original = trio.Semaphore(initial_value, max_value=max_value)
+
+    async def acquire(self) -> None:
+        if not self._fast_acquire:
+            await self.__original.acquire()
+            return
+
+        # This is the "fast path" where we don't let other tasks run
+        await trio.lowlevel.checkpoint_if_cancelled()
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            await self.__original._lot.park()
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    @property
+    def max_value(self) -> int | None:
+        return self.__original.max_value
+
+    @property
+    def value(self) -> int:
+        return self.__original.value
+
+    def release(self) -> None:
+        self.__original.release()
+
+    def statistics(self) -> SemaphoreStatistics:
+        orig_statistics = self.__original.statistics()
+        return SemaphoreStatistics(orig_statistics.tasks_waiting)
+
+
+class CapacityLimiter(BaseCapacityLimiter):
+    __slots__ = ("__original",)
+
+    def __new__(
+        cls,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
+    ) -> Self:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        total_tokens: float | None = None,
+        *,
+        original: trio.CapacityLimiter | None = None,
+    ) -> None:
+        if original is not None:
+            self.__original = original
+        else:
+            assert total_tokens is not None
+            self.__original = trio.CapacityLimiter(total_tokens)
+
+    async def __aenter__(self) -> None:
+        return await self.__original.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.__original.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def total_tokens(self) -> float:
+        return self.__original.total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        self.__original.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        return self.__original.borrowed_tokens
+
+    @property
+    def available_tokens(self) -> float:
+        return self.__original.available_tokens
+
+    def acquire_nowait(self) -> None:
+        try:
+            self.__original.acquire_nowait()
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        try:
+            self.__original.acquire_on_behalf_of_nowait(borrower)
+        except trio.WouldBlock:
+            raise WouldBlock from None
+
+    async def acquire(self) -> None:
+        await self.__original.acquire()
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self.__original.acquire_on_behalf_of(borrower)
+
+    def release(self) -> None:
+        return self.__original.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        return self.__original.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        orig = self.__original.statistics()
+        return CapacityLimiterStatistics(
+            borrowed_tokens=orig.borrowed_tokens,
+            total_tokens=orig.total_tokens,
+            borrowers=tuple(orig.borrowers),
+            tasks_waiting=orig.tasks_waiting,
+        )
+
+
+_capacity_limiter_wrapper: trio.lowlevel.RunVar = RunVar("_capacity_limiter_wrapper")
+
+
+#
+# Signal handling
+#
+
+
+class _SignalReceiver:
+    _iterator: AsyncIterator[int]
+
+    def __init__(self, signals: tuple[Signals, ...]):
+        self._signals = signals
+
+    def __enter__(self) -> Self:
+        self._cm = trio.open_signal_receiver(*self._signals)
+        self._iterator = self._cm.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        return self._cm.__exit__(exc_type, exc_val, exc_tb)
+
+    def __aiter__(self) -> _SignalReceiver:
+        return self
+
+    async def __anext__(self) -> Signals:
+        signum = await self._iterator.__anext__()
+        return Signals(signum)
+
+
+#
+# Testing and debugging
+#
+
+
+class TestRunner(abc.TestRunner):
+    def __init__(self, **options: Any) -> None:
+        from queue import Queue
+
+        self._call_queue: Queue[Callable[[], object]] = Queue()
+        self._send_stream: (
+            MemoryObjectSendStream[tuple[Awaitable[Any], list[Outcome]]] | None
+        ) = None
+        self._options = options
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> None:
+        if self._send_stream:
+            self._send_stream.close()
+            while self._send_stream is not None:
+                self._call_queue.get()()
+
+    def is_running(self) -> bool:
+        return trio.lowlevel.in_trio_task()
+
+    async def _run_tests_and_fixtures(self) -> None:
+        self._send_stream, receive_stream = create_memory_object_stream[
+            tuple[Awaitable[Any], list[Outcome]]
+        ](1)
+        with receive_stream:
+            async for awaitable, outcome_holder in receive_stream:
+                try:
+                    retval = await awaitable
+                except BaseException as exc:
+                    outcome_holder.append(Error(exc))
+                else:
+                    outcome_holder.append(Value(retval))
+
+    def _main_task_finished(self, outcome: object) -> None:
+        self._send_stream = None
+
+    def _call_in_runner_task(
+        self,
+        func: Callable[P, Awaitable[T_Retval]],
+        /,
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> T_Retval:
+        if self._send_stream is None:
+            trio.lowlevel.start_guest_run(
+                self._run_tests_and_fixtures,
+                run_sync_soon_threadsafe=self._call_queue.put,
+                done_callback=self._main_task_finished,
+                **self._options,
+            )
+            while self._send_stream is None:
+                self._call_queue.get()()
+
+        outcome_holder: list[Outcome] = []
+        self._send_stream.send_nowait((func(*args, **kwargs), outcome_holder))
+        while not outcome_holder:
+            self._call_queue.get()()
+
+        return outcome_holder[0].unwrap()
+
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[T_Retval, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[T_Retval]:
+        asyncgen = fixture_func(**kwargs)
+        fixturevalue: T_Retval = self._call_in_runner_task(asyncgen.asend, None)
+
+        yield fixturevalue
+
+        try:
+            self._call_in_runner_task(asyncgen.asend, None)
+        except StopAsyncIteration:
+            pass
+        else:
+            self._call_in_runner_task(asyncgen.aclose)
+            raise RuntimeError("Async generator fixture did not stop")
+
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, T_Retval]],
+        kwargs: dict[str, Any],
+    ) -> T_Retval:
+        return self._call_in_runner_task(fixture_func, **kwargs)
+
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        self._call_in_runner_task(test_func, **kwargs)
+
+
+class TrioTaskInfo(TaskInfo):
+    def __init__(self, task: trio.lowlevel.Task):
+        parent_id = None
+        if task.parent_nursery and task.parent_nursery.parent_task:
+            parent_id = id(task.parent_nursery.parent_task)
+
+        super().__init__(id(task), parent_id, task.name, task.coro)
+        self._task = weakref.proxy(task)
+
+    def has_pending_cancellation(self) -> bool:
+        try:
+            return self._task._cancel_status.effectively_cancelled
+        except ReferenceError:
+            # If the task is no longer around, it surely doesn't have a cancellation
+            # pending
+            return False
+
+
+class TrioBackend(AsyncBackend):
+    @classmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        assert not kwargs, "unreachable, and not supported by Trio"
+        return trio.run(ensure_returns_coro(func), *args, **options)
+
+    @classmethod
+    def current_token(cls) -> object:
+        return trio.lowlevel.current_trio_token()
+
+    @classmethod
+    def current_time(cls) -> float:
+        return trio.current_time()
+
+    @classmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        return trio.Cancelled
+
+    @classmethod
+    async def checkpoint(cls) -> None:
+        await trio.lowlevel.checkpoint()
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        await trio.lowlevel.checkpoint_if_cancelled()
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        await trio.lowlevel.cancel_shielded_checkpoint()
+
+    @classmethod
+    async def sleep(cls, delay: float) -> None:
+        await trio.sleep(delay)
+
+    @classmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> BaseCancelScope:
+        return CancelScope(deadline=deadline, shield=shield)
+
+    @classmethod
+    def current_effective_deadline(cls) -> float:
+        return trio.current_effective_deadline()
+
+    @classmethod
+    def create_task_group(cls) -> abc.TaskGroup:
+        return TaskGroup()
+
+    @classmethod
+    def create_event(cls) -> BaseEvent:
+        return Event()
+
+    @classmethod
+    def create_lock(cls, *, fast_acquire: bool) -> Lock:
+        return Lock(fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> BaseSemaphore:
+        return Semaphore(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+
+    @classmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
+        return CapacityLimiter(total_tokens)
+
+    @classmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: BaseCapacityLimiter | None = None,
+    ) -> T_Retval:
+        def wrapper() -> T_Retval:
+            with claim_worker_thread(TrioBackend, token):
+                return func(*args)
+
+        token = TrioBackend.current_token()
+        return await run_sync(
+            wrapper,
+            abandon_on_cancel=abandon_on_cancel,
+            limiter=cast(trio.CapacityLimiter, limiter),
+        )
+
+    @classmethod
+    def check_cancelled(cls) -> None:
+        trio.from_thread.check_cancelled()
+
+    @classmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_co:
+        trio_token = cast("trio.lowlevel.TrioToken | None", token)
+        try:
+            return trio.from_thread.run(func, *args, trio_token=trio_token)
+        except trio.RunFinishedError:
+            raise RunFinishedError from None
+
+    @classmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        trio_token = cast("trio.lowlevel.TrioToken | None", token)
+        try:
+            return trio.from_thread.run_sync(func, *args, trio_token=trio_token)
+        except trio.RunFinishedError:
+            raise RunFinishedError from None
+
+    @classmethod
+    async def open_process(
+        cls,
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
+        *,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        **kwargs: Any,
+    ) -> Process:
+        def convert_item(item: StrOrBytesPath) -> str:
+            str_or_bytes = os.fspath(item)
+            if isinstance(str_or_bytes, str):
+                return str_or_bytes
+            else:
+                return os.fsdecode(str_or_bytes)
+
+        if isinstance(command, (str, bytes, PathLike)):
+            process = await trio.lowlevel.open_process(
+                convert_item(command),
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=True,
+                **kwargs,
+            )
+        else:
+            process = await trio.lowlevel.open_process(
+                [convert_item(item) for item in command],
+                stdin=stdin,
+                stdout=stdout,
+                stderr=stderr,
+                shell=False,
+                **kwargs,
+            )
+
+        stdin_stream = SendStreamWrapper(process.stdin) if process.stdin else None
+        stdout_stream = ReceiveStreamWrapper(process.stdout) if process.stdout else None
+        stderr_stream = ReceiveStreamWrapper(process.stderr) if process.stderr else None
+        return Process(process, stdin_stream, stdout_stream, stderr_stream)
+
+    @classmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[abc.Process]) -> None:
+        trio.lowlevel.spawn_system_task(_shutdown_process_pool, workers)
+
+    @classmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> SocketStream:
+        family = socket.AF_INET6 if ":" in host else socket.AF_INET
+        trio_socket = trio.socket.socket(family)
+        trio_socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if local_address:
+            await trio_socket.bind(local_address)
+
+        try:
+            await trio_socket.connect((host, port))
+        except BaseException:
+            trio_socket.close()
+            raise
+
+        return SocketStream(trio_socket)
+
+    @classmethod
+    async def connect_unix(cls, path: str | bytes) -> abc.UNIXSocketStream:
+        trio_socket = trio.socket.socket(socket.AF_UNIX)
+        try:
+            await trio_socket.connect(path)
+        except BaseException:
+            trio_socket.close()
+            raise
+
+        return UNIXSocketStream(trio_socket)
+
+    @classmethod
+    def create_tcp_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return TCPSocketListener(sock)
+
+    @classmethod
+    def create_unix_listener(cls, sock: socket.socket) -> abc.SocketListener:
+        return UNIXSocketListener(sock)
+
+    @classmethod
+    async def create_udp_socket(
+        cls,
+        family: socket.AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        trio_socket = trio.socket.socket(family=family, type=socket.SOCK_DGRAM)
+
+        if reuse_port:
+            trio_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+        if local_address:
+            await trio_socket.bind(local_address)
+
+        if remote_address:
+            await trio_socket.connect(remote_address)
+            return ConnectedUDPSocket(trio_socket)
+        else:
+            return UDPSocket(trio_socket)
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: None
+    ) -> abc.UNIXDatagramSocket: ...
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes
+    ) -> abc.ConnectedUNIXDatagramSocket: ...
+
+    @classmethod
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket.socket, remote_path: str | bytes | None
+    ) -> abc.UNIXDatagramSocket | abc.ConnectedUNIXDatagramSocket:
+        trio_socket = trio.socket.from_stdlib_socket(raw_socket)
+
+        if remote_path:
+            await trio_socket.connect(remote_path)
+            return ConnectedUNIXDatagramSocket(trio_socket)
+        else:
+            return UNIXDatagramSocket(trio_socket)
+
+    @classmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> Sequence[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes],
+        ]
+    ]:
+        return await trio.socket.getaddrinfo(host, port, family, type, proto, flags)
+
+    @classmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        return await trio.socket.getnameinfo(sockaddr, flags)
+
+    @classmethod
+    async def wait_readable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            await wait_readable(obj)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("reading from") from None
+
+    @classmethod
+    async def wait_writable(cls, obj: FileDescriptorLike) -> None:
+        try:
+            await wait_writable(obj)
+        except trio.ClosedResourceError as exc:
+            raise ClosedResourceError().with_traceback(exc.__traceback__) from None
+        except trio.BusyResourceError:
+            raise BusyResourceError("writing to") from None
+
+    @classmethod
+    def notify_closing(cls, obj: FileDescriptorLike) -> None:
+        notify_closing(obj)
+
+    @classmethod
+    async def wrap_listener_socket(cls, sock: socket.socket) -> abc.SocketListener:
+        if hasattr(socket, "AF_UNIX") and sock.family == socket.AF_UNIX:
+            return UNIXSocketListener(sock)
+
+        return TCPSocketListener(sock)
+
+    @classmethod
+    async def wrap_stream_socket(cls, sock: socket.socket) -> SocketStream:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return SocketStream(trio_sock)
+
+    @classmethod
+    async def wrap_unix_stream_socket(cls, sock: socket.socket) -> UNIXSocketStream:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UNIXSocketStream(trio_sock)
+
+    @classmethod
+    async def wrap_udp_socket(cls, sock: socket.socket) -> UDPSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UDPSocket(trio_sock)
+
+    @classmethod
+    async def wrap_connected_udp_socket(cls, sock: socket.socket) -> ConnectedUDPSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return ConnectedUDPSocket(trio_sock)
+
+    @classmethod
+    async def wrap_unix_datagram_socket(cls, sock: socket.socket) -> UNIXDatagramSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return UNIXDatagramSocket(trio_sock)
+
+    @classmethod
+    async def wrap_connected_unix_datagram_socket(
+        cls, sock: socket.socket
+    ) -> ConnectedUNIXDatagramSocket:
+        trio_sock = trio.socket.from_stdlib_socket(sock)
+        return ConnectedUNIXDatagramSocket(trio_sock)
+
+    @classmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        try:
+            return _capacity_limiter_wrapper.get()
+        except LookupError:
+            limiter = CapacityLimiter(
+                original=trio.to_thread.current_default_thread_limiter()
+            )
+            _capacity_limiter_wrapper.set(limiter)
+            return limiter
+
+    @classmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> AbstractContextManager[AsyncIterator[Signals]]:
+        return _SignalReceiver(signals)
+
+    @classmethod
+    def get_current_task(cls) -> TaskInfo:
+        task = current_task()
+        return TrioTaskInfo(task)
+
+    @classmethod
+    def get_running_tasks(cls) -> Sequence[TaskInfo]:
+        root_task = current_root_task()
+        assert root_task
+        task_infos = [TrioTaskInfo(root_task)]
+        nurseries = root_task.child_nurseries
+        while nurseries:
+            new_nurseries: list[trio.Nursery] = []
+            for nursery in nurseries:
+                for task in nursery.child_tasks:
+                    task_infos.append(TrioTaskInfo(task))
+                    new_nurseries.extend(task.child_nurseries)
+
+            nurseries = new_nurseries
+
+        return task_infos
+
+    @classmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        from trio.testing import wait_all_tasks_blocked
+
+        await wait_all_tasks_blocked()
+
+    @classmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        return TestRunner(**options)
+
+
+backend_class = TrioBackend
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..67299edcfa971baa47d5da477b69203ed946a80a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f3023d7c232e51b91e9317a78682d5f11565ee67
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_asyncio_selector_thread.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_concurrency_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_concurrency_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ca18060fdcac5b057cb56e453df02edf7c1746f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_concurrency_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6fead4c9c4e8c060c9cf500e17ddbeb293126533
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_contextmanagers.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_eventloop.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_eventloop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eb020d98d55a37beea067afd60acd1cad193f0e5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_eventloop.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7dc7b5e0456559fb0106c7ba2c9e230471397e11
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_fileio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_fileio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29f5e5287b705f3e0bbab9f90dde1f6f17bb3550
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_fileio.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_futures.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_futures.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a284982afb18704ed9601c6b4535da1409b15743
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_futures.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_resources.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_resources.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..817cf7e6a8b2876b4875f8f025c79b3f29501772
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_resources.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_signals.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_signals.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1544b41b0a4d5acb3ab6b83145d499752058b079
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_signals.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_sockets.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_sockets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc910d2b594882ac50fe18112119ce520615499e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_sockets.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_streams.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_streams.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1a0f51e53635a55f184082f589908f6cff03a25
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_streams.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41caaf46ceb639dfc483b12c426a77edf23aec26
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_subprocesses.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_synchronization.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_synchronization.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fc51944afda28a55628b9444698621e8c4d0d4ab
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_synchronization.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tasks.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tasks.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ad0410e791d9cbe243fa963dc6a17331ce417de0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tasks.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tempfile.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tempfile.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c82a7a00eb39b7e98b2e7b7d3bdd6a506cbc06b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_tempfile.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_testing.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_testing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bb1491b27628df099efc49c840dd033e8f762d28
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_testing.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_typedattr.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_typedattr.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fbe52a182d483044bf763674e44ee46294fc8a15
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/__pycache__/_typedattr.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_asyncio_selector_thread.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_asyncio_selector_thread.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f35bae568e33e6a9e1219761c83cc8350fa0532
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_asyncio_selector_thread.py
@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import asyncio
+import socket
+import threading
+from collections.abc import Callable
+from selectors import EVENT_READ, EVENT_WRITE, DefaultSelector
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+_selector_lock = threading.Lock()
+_selector: Selector | None = None
+
+
+class Selector:
+    def __init__(self) -> None:
+        self._thread = threading.Thread(target=self.run, name="AnyIO socket selector")
+        self._selector = DefaultSelector()
+        self._send, self._receive = socket.socketpair()
+        self._send.setblocking(False)
+        self._receive.setblocking(False)
+        # This somewhat reduces the amount of memory wasted queueing up data
+        # for wakeups. With these settings, maximum number of 1-byte sends
+        # before getting BlockingIOError:
+        #   Linux 4.8: 6
+        #   macOS (darwin 15.5): 1
+        #   Windows 10: 525347
+        # Windows you're weird. (And on Windows setting SNDBUF to 0 makes send
+        # blocking, even on non-blocking sockets, so don't do that.)
+        self._receive.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 1)
+        self._send.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1)
+        # On Windows this is a TCP socket so this might matter. On other
+        # platforms this fails b/c AF_UNIX sockets aren't actually TCP.
+        try:
+            self._send.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        except OSError:
+            pass
+
+        self._selector.register(self._receive, EVENT_READ)
+        self._closed = False
+
+    def start(self) -> None:
+        self._thread.start()
+        threading._register_atexit(self._stop)  # type: ignore[attr-defined]
+
+    def _stop(self) -> None:
+        global _selector
+        self._closed = True
+        self._notify_self()
+        self._send.close()
+        self._thread.join()
+        self._selector.unregister(self._receive)
+        self._receive.close()
+        self._selector.close()
+        _selector = None
+        assert not self._selector.get_map(), (
+            "selector still has registered file descriptors after shutdown"
+        )
+
+    def _notify_self(self) -> None:
+        try:
+            self._send.send(b"\x00")
+        except BlockingIOError:
+            pass
+
+    def add_reader(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            self._selector.register(fd, EVENT_READ, {EVENT_READ: (loop, callback)})
+        else:
+            if EVENT_READ in key.data:
+                raise ValueError(
+                    "this file descriptor is already registered for reading"
+                )
+
+            key.data[EVENT_READ] = loop, callback
+            self._selector.modify(fd, key.events | EVENT_READ, key.data)
+
+        self._notify_self()
+
+    def add_writer(self, fd: FileDescriptorLike, callback: Callable[[], Any]) -> None:
+        loop = asyncio.get_running_loop()
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            self._selector.register(fd, EVENT_WRITE, {EVENT_WRITE: (loop, callback)})
+        else:
+            if EVENT_WRITE in key.data:
+                raise ValueError(
+                    "this file descriptor is already registered for writing"
+                )
+
+            key.data[EVENT_WRITE] = loop, callback
+            self._selector.modify(fd, key.events | EVENT_WRITE, key.data)
+
+        self._notify_self()
+
+    def remove_reader(self, fd: FileDescriptorLike) -> bool:
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            return False
+
+        if new_events := key.events ^ EVENT_READ:
+            del key.data[EVENT_READ]
+            self._selector.modify(fd, new_events, key.data)
+        else:
+            self._selector.unregister(fd)
+
+        return True
+
+    def remove_writer(self, fd: FileDescriptorLike) -> bool:
+        try:
+            key = self._selector.get_key(fd)
+        except KeyError:
+            return False
+
+        if new_events := key.events ^ EVENT_WRITE:
+            del key.data[EVENT_WRITE]
+            self._selector.modify(fd, new_events, key.data)
+        else:
+            self._selector.unregister(fd)
+
+        return True
+
+    def run(self) -> None:
+        while not self._closed:
+            for key, events in self._selector.select():
+                if key.fileobj is self._receive:
+                    try:
+                        while self._receive.recv(4096):
+                            pass
+                    except BlockingIOError:
+                        pass
+
+                    continue
+
+                if events & EVENT_READ:
+                    loop, callback = key.data[EVENT_READ]
+                    self.remove_reader(key.fd)
+                    try:
+                        loop.call_soon_threadsafe(callback)
+                    except RuntimeError:
+                        pass  # the loop was already closed
+
+                if events & EVENT_WRITE:
+                    loop, callback = key.data[EVENT_WRITE]
+                    self.remove_writer(key.fd)
+                    try:
+                        loop.call_soon_threadsafe(callback)
+                    except RuntimeError:
+                        pass  # the loop was already closed
+
+
+def get_selector() -> Selector:
+    global _selector
+
+    with _selector_lock:
+        if _selector is None:
+            _selector = Selector()
+            _selector.start()
+
+        return _selector
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_concurrency_utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_concurrency_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..f66229a57d7b0d5f793bdfe568a751770939c924
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_concurrency_utils.py
@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+from inspect import iscoroutine
+
+__all__ = ("amap", "as_completed", "gather")
+
+from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Iterable
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Any, TypeVar, overload
+
+from ..abc._tasks import get_coro_name
+from ._exceptions import BrokenResourceError
+from ._streams import create_memory_object_stream
+from ._tasks import TaskHandle, create_task_group
+
+if TYPE_CHECKING:
+    from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+
+R = TypeVar("R")
+S = TypeVar("S")
+T = TypeVar("T")
+U = TypeVar("U")
+V = TypeVar("V")
+W = TypeVar("W")
+
+
+@overload
+async def gather(
+    coro1: Coroutine[Any, Any, R], coro2: Coroutine[Any, Any, S], /
+) -> tuple[R, S]: ...
+
+
+@overload
+async def gather(
+    coro1: Coroutine[Any, Any, R],
+    coro2: Coroutine[Any, Any, S],
+    coro3: Coroutine[Any, Any, T],
+    /,
+) -> tuple[R, S, T]: ...
+
+
+@overload
+async def gather(
+    coro1: Coroutine[Any, Any, R],
+    coro2: Coroutine[Any, Any, S],
+    coro3: Coroutine[Any, Any, T],
+    coro4: Coroutine[Any, Any, U],
+    /,
+) -> tuple[R, S, T, U]: ...
+
+
+@overload
+async def gather(
+    coro1: Coroutine[Any, Any, R],
+    coro2: Coroutine[Any, Any, S],
+    coro3: Coroutine[Any, Any, T],
+    coro4: Coroutine[Any, Any, U],
+    coro5: Coroutine[Any, Any, V],
+    /,
+) -> tuple[R, S, T, U, V]: ...
+
+
+@overload
+async def gather(
+    coro1: Coroutine[Any, Any, R],
+    coro2: Coroutine[Any, Any, S],
+    coro3: Coroutine[Any, Any, T],
+    coro4: Coroutine[Any, Any, U],
+    coro5: Coroutine[Any, Any, V],
+    coro6: Coroutine[Any, Any, W],
+    /,
+) -> tuple[R, S, T, U, V, W]: ...
+
+
+# handle arbitrary length if awaitables are all of the same type
+@overload
+async def gather(*coros: Coroutine[Any, Any, R]) -> tuple[R, ...]: ...
+
+
+async def gather(*coros: Coroutine[Any, Any, Any]) -> tuple[Any, ...]:
+    """
+    Run coroutines concurrently in a task group. The order of result values corresponds
+    to the order of coroutines passed.
+
+    :param coros: coroutine objects to run as tasks
+    :return: task results for each argument in the same order as they were passed
+
+    """
+    handles: list[TaskHandle[Any]] = []
+    async with create_task_group() as tg:
+        handles.extend(tg.create_task(coro) for coro in coros)
+
+    return tuple(h.return_value for h in handles)
+
+
+@asynccontextmanager
+async def as_completed(
+    *awaitables: Awaitable[R],
+) -> AsyncGenerator[MemoryObjectReceiveStream[TaskHandle[R]]]:
+    """
+    Run awaitable objects concurrently in a task group, returning an iterator which can
+    be used to get finished task handles in the order they complete.
+
+    :param awaitables: awaitable objects to run as tasks
+    :return: MemoryObjectReceiveStream for iterating over task handles as tasks complete.
+
+    """
+    if not awaitables:
+        raise ValueError("as_completed() takes at least one awaitable")
+
+    send, recv = create_memory_object_stream[TaskHandle[R]](len(awaitables))
+    task_handles: list[TaskHandle[R]] = []
+
+    async def runner(
+        awaitable: Awaitable[R],
+        index: int,
+        _send: MemoryObjectSendStream[TaskHandle[R]],
+    ) -> R:
+        async with _send:
+            try:
+                return await awaitable
+            finally:
+                try:
+                    _send.send_nowait(task_handles[index])
+                except BrokenResourceError:
+                    pass
+
+    async with recv, create_task_group() as tg:
+        async with send:
+            for i, awaitable in enumerate(awaitables):
+                name = get_coro_name(awaitable) if iscoroutine(awaitable) else None
+                task_handles.append(
+                    tg.start_soon(runner, awaitable, i, send.clone(), name=name)
+                )
+        try:
+            yield recv
+        finally:
+            tg.cancel_scope.cancel()
+
+
+async def amap(
+    func: Callable[[T], Coroutine[Any, Any, R]], args: Iterable[T]
+) -> list[R]:
+    """
+    Run the given coroutine function concurrently for multiple argument values.
+
+    :param func: a coroutine function that takes a single argument
+    :param args: a sequence of argument values to pass to ``func``
+    :return: task results for each argument in the same order as they were passed
+
+    """
+    handles: list[TaskHandle[R]] = []
+    async with create_task_group() as tg:
+        handles.extend(tg.start_soon(func, arg) for arg in args)
+
+    return [h.return_value for h in handles]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_contextmanagers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_contextmanagers.py
new file mode 100644
index 0000000000000000000000000000000000000000..302f32b0c78a7071605b195c55054cfdb0b55f37
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_contextmanagers.py
@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from contextlib import AbstractAsyncContextManager, AbstractContextManager
+from inspect import isasyncgen, iscoroutine, isgenerator
+from types import TracebackType
+from typing import Protocol, TypeVar, cast, final
+
+_T_co = TypeVar("_T_co", covariant=True)
+_ExitT_co = TypeVar("_ExitT_co", covariant=True, bound="bool | None")
+
+
+class _SupportsCtxMgr(Protocol[_T_co, _ExitT_co]):
+    def __contextmanager__(self) -> AbstractContextManager[_T_co, _ExitT_co]: ...
+
+
+class _SupportsAsyncCtxMgr(Protocol[_T_co, _ExitT_co]):
+    def __asynccontextmanager__(
+        self,
+    ) -> AbstractAsyncContextManager[_T_co, _ExitT_co]: ...
+
+
+class ContextManagerMixin:
+    """
+    Mixin class providing context manager functionality via a generator-based
+    implementation.
+
+    This class allows you to implement a context manager via :meth:`__contextmanager__`
+    which should return a generator. The mechanics are meant to mirror those of
+    :func:`@contextmanager <contextlib.contextmanager>`.
+
+    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
+        that once you enter it, you can't re-enter before first exiting it.
+
+    .. seealso:: :doc:`contextmanagers`
+    """
+
+    __cm: AbstractContextManager[object, bool | None] | None = None
+
+    @final
+    def __enter__(self: _SupportsCtxMgr[_T_co, bool | None]) -> _T_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, ContextManagerMixin)
+        if self.__cm is not None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has already been entered"
+            )
+
+        cm = self.__contextmanager__()
+        if not isinstance(cm, AbstractContextManager):
+            if isgenerator(cm):
+                raise TypeError(
+                    "__contextmanager__() returned a generator object instead of "
+                    "a context manager. Did you forget to add the @contextmanager "
+                    "decorator?"
+                )
+
+            raise TypeError(
+                f"__contextmanager__() did not return a context manager object, "
+                f"but {cm.__class__!r}"
+            )
+
+        if cm is self:
+            raise TypeError(
+                f"{self.__class__.__qualname__}.__contextmanager__() returned "
+                f"self. Did you forget to add the @contextmanager decorator and a "
+                f"'yield' statement?"
+            )
+
+        value = cm.__enter__()
+        self.__cm = cm
+        return value
+
+    @final
+    def __exit__(
+        self: _SupportsCtxMgr[object, _ExitT_co],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> _ExitT_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, ContextManagerMixin)
+        if self.__cm is None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has not been entered yet"
+            )
+
+        # Prevent circular references
+        cm = self.__cm
+        del self.__cm
+
+        return cast(_ExitT_co, cm.__exit__(exc_type, exc_val, exc_tb))
+
+    @abstractmethod
+    def __contextmanager__(self) -> AbstractContextManager[object, bool | None]:
+        """
+        Implement your context manager logic here.
+
+        This method **must** be decorated with
+        :func:`@contextmanager <contextlib.contextmanager>`.
+
+        .. note:: Remember that the ``yield`` will raise any exception raised in the
+            enclosed context block, so use a ``finally:`` block to clean up resources!
+
+        :return: a context manager object
+        """
+
+
+class AsyncContextManagerMixin:
+    """
+    Mixin class providing async context manager functionality via a generator-based
+    implementation.
+
+    This class allows you to implement a context manager via
+    :meth:`__asynccontextmanager__`. The mechanics are meant to mirror those of
+    :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
+
+    .. note:: Classes using this mix-in are not reentrant as context managers, meaning
+        that once you enter it, you can't re-enter before first exiting it.
+
+    .. seealso:: :doc:`contextmanagers`
+    """
+
+    __cm: AbstractAsyncContextManager[object, bool | None] | None = None
+
+    @final
+    async def __aenter__(self: _SupportsAsyncCtxMgr[_T_co, bool | None]) -> _T_co:
+        # Needed for mypy to assume self still has the __cm member
+        assert isinstance(self, AsyncContextManagerMixin)
+        if self.__cm is not None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has already been entered"
+            )
+
+        cm = self.__asynccontextmanager__()
+        if not isinstance(cm, AbstractAsyncContextManager):
+            if isasyncgen(cm):
+                raise TypeError(
+                    "__asynccontextmanager__() returned an async generator instead of "
+                    "an async context manager. Did you forget to add the "
+                    "@asynccontextmanager decorator?"
+                )
+            elif iscoroutine(cm):
+                cm.close()
+                raise TypeError(
+                    "__asynccontextmanager__() returned a coroutine object instead of "
+                    "an async context manager. Did you forget to add the "
+                    "@asynccontextmanager decorator and a 'yield' statement?"
+                )
+
+            raise TypeError(
+                f"__asynccontextmanager__() did not return an async context manager, "
+                f"but {cm.__class__!r}"
+            )
+
+        if cm is self:
+            raise TypeError(
+                f"{self.__class__.__qualname__}.__asynccontextmanager__() returned "
+                f"self. Did you forget to add the @asynccontextmanager decorator and a "
+                f"'yield' statement?"
+            )
+
+        value = await cm.__aenter__()
+        self.__cm = cm
+        return value
+
+    @final
+    async def __aexit__(
+        self: _SupportsAsyncCtxMgr[object, _ExitT_co],
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> _ExitT_co:
+        assert isinstance(self, AsyncContextManagerMixin)
+        if self.__cm is None:
+            raise RuntimeError(
+                f"this {self.__class__.__qualname__} has not been entered yet"
+            )
+
+        # Prevent circular references
+        cm = self.__cm
+        del self.__cm
+
+        return cast(_ExitT_co, await cm.__aexit__(exc_type, exc_val, exc_tb))
+
+    @abstractmethod
+    def __asynccontextmanager__(
+        self,
+    ) -> AbstractAsyncContextManager[object, bool | None]:
+        """
+        Implement your async context manager logic here.
+
+        This method **must** be decorated with
+        :func:`@asynccontextmanager <contextlib.asynccontextmanager>`.
+
+        .. note:: Remember that the ``yield`` will raise any exception raised in the
+            enclosed context block, so use a ``finally:`` block to clean up resources!
+
+        :return: an async context manager object
+        """
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_eventloop.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_eventloop.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3e2ab1cc172f2fbd94f244ab110cb16aa7eb8eb
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_eventloop.py
@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import math
+import sys
+import threading
+from collections.abc import Awaitable, Callable, Generator
+from contextlib import contextmanager
+from contextvars import Token
+from importlib import import_module
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from ._exceptions import NoEventLoopError
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+sniffio: Any
+try:
+    import sniffio
+except ModuleNotFoundError:
+    sniffio = None
+
+if TYPE_CHECKING:
+    from ..abc import AsyncBackend
+
+# This must be updated when new backends are introduced
+BACKENDS = "asyncio", "trio"
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+threadlocals = threading.local()
+loaded_backends: dict[str, type[AsyncBackend]] = {}
+
+
+def run(
+    func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+    *args: Unpack[PosArgsT],
+    backend: str = "asyncio",
+    backend_options: dict[str, Any] | None = None,
+) -> T_Retval:
+    """
+    Run the given coroutine function in an asynchronous event loop.
+
+    The current thread must not be already running an event loop.
+
+    :param func: a coroutine function
+    :param args: positional arguments to ``func``
+    :param backend: name of the asynchronous event loop implementation – currently
+        either ``asyncio`` or ``trio``
+    :param backend_options: keyword arguments to call the backend ``run()``
+        implementation with (documented :ref:`here <backend options>`)
+    :return: the return value of the coroutine function
+    :raises RuntimeError: if an asynchronous event loop is already running in this
+        thread
+    :raises LookupError: if the named backend is not found
+
+    """
+    if asynclib_name := current_async_library():
+        raise RuntimeError(f"Already running {asynclib_name} in this thread")
+
+    try:
+        async_backend = get_async_backend(backend)
+    except ImportError as exc:
+        if backend in BACKENDS:
+            raise LookupError(
+                f"Backend {backend!r} is not available. "
+                f"Install it with: pip install anyio[{backend}]"
+            ) from exc
+
+        raise LookupError(f"No such backend: {backend}") from exc
+
+    token = None
+    if asynclib_name is None:
+        # Since we're in control of the event loop, we can cache the name of the async
+        # library
+        token = set_current_async_library(backend)
+
+    try:
+        backend_options = backend_options or {}
+        return async_backend.run(func, args, {}, backend_options)
+    finally:
+        reset_current_async_library(token)
+
+
+async def sleep(delay: float) -> None:
+    """
+    Pause the current task for the specified duration.
+
+    :param delay: the duration, in seconds
+
+    """
+    return await get_async_backend().sleep(delay)
+
+
+async def sleep_forever() -> None:
+    """
+    Pause the current task until it's cancelled.
+
+    This is a shortcut for ``sleep(math.inf)``.
+
+    .. versionadded:: 3.1
+
+    """
+    await sleep(math.inf)
+
+
+async def sleep_until(deadline: float) -> None:
+    """
+    Pause the current task until the given time.
+
+    :param deadline: the absolute time to wake up at (according to the internal
+        monotonic clock of the event loop)
+
+    .. versionadded:: 3.1
+
+    """
+    now = current_time()
+    await sleep(max(deadline - now, 0))
+
+
+def current_time() -> float:
+    """
+    Return the current value of the event loop's internal clock.
+
+    :return: the clock value (seconds)
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().current_time()
+
+
+def get_all_backends() -> tuple[str, ...]:
+    """Return a tuple of the names of all built-in backends."""
+    return BACKENDS
+
+
+def get_available_backends() -> tuple[str, ...]:
+    """
+    Test for the availability of built-in backends.
+
+    :return a tuple of the built-in backend names that were successfully imported
+
+    .. versionadded:: 4.12
+
+    """
+    available_backends: list[str] = []
+    for backend_name in get_all_backends():
+        try:
+            get_async_backend(backend_name)
+        except ImportError:
+            continue
+
+        available_backends.append(backend_name)
+
+    return tuple(available_backends)
+
+
+def get_cancelled_exc_class() -> type[BaseException]:
+    """
+    Return the current async library's cancellation exception class.
+
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().cancelled_exception_class()
+
+
+#
+# Private API
+#
+
+
+@contextmanager
+def claim_worker_thread(
+    backend_class: type[AsyncBackend], token: object
+) -> Generator[Any, None, None]:
+    from ..lowlevel import EventLoopToken
+
+    threadlocals.current_token = EventLoopToken(backend_class, token)
+    try:
+        yield
+    finally:
+        del threadlocals.current_token
+
+
+def get_async_backend(asynclib_name: str | None = None) -> type[AsyncBackend]:
+    if asynclib_name is None:
+        asynclib_name = current_async_library()
+        if not asynclib_name:
+            raise NoEventLoopError(
+                f"Not currently running on any asynchronous event loop. "
+                f"Available async backends: {', '.join(get_all_backends())}"
+            )
+
+    # We use our own dict instead of sys.modules to get the already imported back-end
+    # class because the appropriate modules in sys.modules could potentially be only
+    # partially initialized
+    try:
+        return loaded_backends[asynclib_name]
+    except KeyError:
+        module = import_module(f"anyio._backends._{asynclib_name}")
+        loaded_backends[asynclib_name] = module.backend_class
+        return module.backend_class
+
+
+def current_async_library() -> str | None:
+    if sniffio is None:
+        # If sniffio is not installed, we assume we're either running asyncio or nothing
+        import asyncio
+
+        try:
+            asyncio.get_running_loop()
+            return "asyncio"
+        except RuntimeError:
+            pass
+    else:
+        try:
+            return sniffio.current_async_library()
+        except sniffio.AsyncLibraryNotFoundError:
+            pass
+
+    return None
+
+
+def set_current_async_library(asynclib_name: str | None) -> Token | None:
+    # no-op if sniffio is not installed
+    if sniffio is None:
+        return None
+
+    return sniffio.current_async_library_cvar.set(asynclib_name)
+
+
+def reset_current_async_library(token: Token | None) -> None:
+    if token is not None:
+        sniffio.current_async_library_cvar.reset(token)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..7d9165f53ab239182f9158f8eeec7ea27b417c92
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_exceptions.py
@@ -0,0 +1,205 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Generator
+from textwrap import dedent
+from typing import Any
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import BaseExceptionGroup
+
+
+class BrokenResourceError(Exception):
+    """
+    Raised when trying to use a resource that has been rendered unusable due to external
+    causes (e.g. a send stream whose peer has disconnected).
+    """
+
+
+class BrokenWorkerProcess(Exception):
+    """
+    Raised by :meth:`~anyio.to_process.run_sync` if the worker process terminates abruptly or
+    otherwise misbehaves.
+    """
+
+
+class BrokenWorkerInterpreter(Exception):
+    """
+    Raised by :meth:`~anyio.to_interpreter.run_sync` if an unexpected exception is
+    raised in the subinterpreter.
+    """
+
+    def __init__(self, excinfo: Any):
+        # This was adapted from concurrent.futures.interpreter.ExecutionFailed
+        msg = excinfo.formatted
+        if not msg:
+            if excinfo.type and excinfo.msg:
+                msg = f"{excinfo.type.__name__}: {excinfo.msg}"
+            else:
+                msg = excinfo.type.__name__ or excinfo.msg
+
+        super().__init__(msg)
+        self.excinfo = excinfo
+
+    def __str__(self) -> str:
+        try:
+            formatted = self.excinfo.errdisplay
+        except Exception:
+            return super().__str__()
+        else:
+            return dedent(
+                f"""
+                {super().__str__()}
+
+                Uncaught in the interpreter:
+
+                {formatted}
+                """.strip()
+            )
+
+
+class BusyResourceError(Exception):
+    """
+    Raised when two tasks are trying to read from or write to the same resource
+    concurrently.
+    """
+
+    def __init__(self, action: str):
+        super().__init__(f"Another task is already {action} this resource")
+
+
+class ClosedResourceError(Exception):
+    """Raised when trying to use a resource that has been closed."""
+
+
+class ConnectionFailed(OSError):
+    """
+    Raised when a connection attempt fails.
+
+    .. note:: This class inherits from :exc:`OSError` for backwards compatibility.
+    """
+
+
+def iterate_exceptions(
+    exception: BaseException,
+) -> Generator[BaseException, None, None]:
+    if isinstance(exception, BaseExceptionGroup):
+        for exc in exception.exceptions:
+            yield from iterate_exceptions(exc)
+    else:
+        yield exception
+
+
+class DelimiterNotFound(Exception):
+    """
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    maximum number of bytes has been read without the delimiter being found.
+    """
+
+    def __init__(self, max_bytes: int) -> None:
+        super().__init__(
+            f"The delimiter was not found among the first {max_bytes} bytes"
+        )
+
+
+class EndOfStream(Exception):
+    """
+    Raised when trying to read from a stream that has been closed from the other end.
+    """
+
+
+class IncompleteRead(Exception):
+    """
+    Raised during
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_exactly` or
+    :meth:`~anyio.streams.buffered.BufferedByteReceiveStream.receive_until` if the
+    connection is closed before the requested amount of bytes has been read.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The stream was closed before the read operation could be completed"
+        )
+
+
+class TypedAttributeLookupError(LookupError):
+    """
+    Raised by :meth:`~anyio.TypedAttributeProvider.extra` when the given typed attribute
+    is not found and no default value has been given.
+    """
+
+
+class WouldBlock(Exception):
+    """Raised by ``X_nowait`` functions if ``X()`` would block."""
+
+
+class NoEventLoopError(RuntimeError):
+    """
+    Raised by several functions that require an event loop to be running in the current
+    thread when there is no running event loop.
+
+    This is also raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync`
+    if not calling from an AnyIO worker thread, and no ``token`` was passed.
+    """
+
+
+class RunFinishedError(RuntimeError):
+    """
+    Raised by :func:`.from_thread.run` and :func:`.from_thread.run_sync` if the event
+    loop associated with the explicitly passed token has already finished.
+    """
+
+    def __init__(self) -> None:
+        super().__init__(
+            "The event loop associated with the given token has already finished"
+        )
+
+
+class TaskFailed(Exception):
+    """
+    Raised when awaiting on, or attempting to access the return value of, a
+    :class:`.TaskHandle` that raised an exception.
+    """
+
+
+class TaskCancelled(TaskFailed):
+    """
+    Raised when awaiting on, or attempting to access the return value of, a
+    :class:`.TaskHandle` that was cancelled.
+    """
+
+
+class TaskNotFinished(Exception):
+    """
+    Raised when attempting to access the return value or exception of a
+    :class:`.TaskHandle` that is still pending completion.
+    """
+
+
+class FutureFailed(Exception):
+    """
+    Raised when awaiting on, or attempting to access the return value of, a
+    :class:`.Future` that raised an exception.
+    """
+
+
+class FutureCancelled(FutureFailed):
+    """
+    Raised when attempting to access the return value or exception of a
+    :class:`.Future` that was cancelled.
+    """
+
+
+class FutureNotFinished(Exception):
+    """
+    Raised when attempting to access the return value or exception of a
+    :class:`.Future` that is still pending completion.
+    """
+
+
+class FutureAlreadyFinished(Exception):
+    """
+    Raised when attempting set a result of or await a
+    :class:`.Future` that has already completed.
+    """
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_fileio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_fileio.py
new file mode 100644
index 0000000000000000000000000000000000000000..498eef41d19fde3991f05472e0bc385c520f49ec
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_fileio.py
@@ -0,0 +1,1045 @@
+from __future__ import annotations
+
+import os
+import pathlib
+import sys
+from collections.abc import (
+    AsyncIterator,
+    Callable,
+    Iterable,
+    Iterator,
+    Sequence,
+)
+from dataclasses import dataclass
+from functools import partial
+from os import PathLike
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    ClassVar,
+    Final,
+    Generic,
+    TypeVar,
+    overload,
+)
+
+from .. import to_thread
+from ..abc import AsyncResource
+from ._synchronization import CapacityLimiter
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+if sys.version_info >= (3, 14):
+    from pathlib.types import PathInfo
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
+else:
+    ReadableBuffer = OpenBinaryMode = OpenTextMode = WriteableBuffer = object
+
+
+T = TypeVar("T", bound="Path")
+
+
+class AsyncFile(AsyncResource, Generic[AnyStr]):
+    """
+    An asynchronous file object.
+
+    This class wraps a standard file object and provides async friendly versions of the
+    following blocking methods (where available on the original file object):
+
+    * read
+    * read1
+    * readline
+    * readlines
+    * readinto
+    * readinto1
+    * write
+    * writelines
+    * truncate
+    * seek
+    * tell
+    * flush
+
+    All other methods are directly passed through.
+
+    This class supports the asynchronous context manager protocol which closes the
+    underlying file at the end of the context block.
+
+    This class also supports asynchronous iteration::
+
+        async with await open_file(...) as f:
+            async for line in f:
+                print(line)
+    """
+
+    def __init__(
+        self, fp: IO[AnyStr], *, limiter: CapacityLimiter | None = None
+    ) -> None:
+        if limiter is not None and not isinstance(limiter, CapacityLimiter):
+            raise TypeError(
+                f"limiter must be a CapacityLimiter or None, not "
+                f"{limiter.__class__.__name__}"
+            )
+
+        self._fp: Any = fp
+        self._limiter = limiter
+
+    def __getattr__(self, name: str) -> object:
+        return getattr(self._fp, name)
+
+    @property
+    def limiter(self) -> CapacityLimiter | None:
+        """The capacity limiter used by this file object, if not the global limiter."""
+        return self._limiter
+
+    @property
+    def wrapped(self) -> IO[AnyStr]:
+        """The wrapped file object."""
+        return self._fp
+
+    async def __aiter__(self) -> AsyncIterator[AnyStr]:
+        while True:
+            line = await self.readline()
+            if line:
+                yield line
+            else:
+                break
+
+    async def aclose(self) -> None:
+        return await to_thread.run_sync(self._fp.close, limiter=self._limiter)
+
+    async def read(self, size: int = -1) -> AnyStr:
+        return await to_thread.run_sync(self._fp.read, size, limiter=self._limiter)
+
+    async def read1(self: AsyncFile[bytes], size: int = -1) -> bytes:
+        return await to_thread.run_sync(self._fp.read1, size, limiter=self._limiter)
+
+    async def readline(self) -> AnyStr:
+        return await to_thread.run_sync(self._fp.readline, limiter=self._limiter)
+
+    async def readlines(self) -> list[AnyStr]:
+        return await to_thread.run_sync(self._fp.readlines, limiter=self._limiter)
+
+    async def readinto(self: AsyncFile[bytes], b: WriteableBuffer) -> int:
+        return await to_thread.run_sync(self._fp.readinto, b, limiter=self._limiter)
+
+    async def readinto1(self: AsyncFile[bytes], b: WriteableBuffer) -> int:
+        return await to_thread.run_sync(self._fp.readinto1, b, limiter=self._limiter)
+
+    @overload
+    async def write(self: AsyncFile[bytes], b: ReadableBuffer) -> int: ...
+
+    @overload
+    async def write(self: AsyncFile[str], b: str) -> int: ...
+
+    async def write(self, b: ReadableBuffer | str) -> int:
+        return await to_thread.run_sync(self._fp.write, b, limiter=self._limiter)
+
+    @overload
+    async def writelines(
+        self: AsyncFile[bytes], lines: Iterable[ReadableBuffer]
+    ) -> None: ...
+
+    @overload
+    async def writelines(self: AsyncFile[str], lines: Iterable[str]) -> None: ...
+
+    async def writelines(self, lines: Iterable[ReadableBuffer] | Iterable[str]) -> None:
+        return await to_thread.run_sync(
+            self._fp.writelines, lines, limiter=self._limiter
+        )
+
+    async def truncate(self, size: int | None = None) -> int:
+        return await to_thread.run_sync(self._fp.truncate, size, limiter=self._limiter)
+
+    async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int:
+        return await to_thread.run_sync(
+            self._fp.seek, offset, whence, limiter=self._limiter
+        )
+
+    async def tell(self) -> int:
+        return await to_thread.run_sync(self._fp.tell, limiter=self._limiter)
+
+    async def flush(self) -> None:
+        return await to_thread.run_sync(self._fp.flush, limiter=self._limiter)
+
+
+@overload
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: OpenBinaryMode,
+    buffering: int = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
+    closefd: bool = ...,
+    opener: Callable[[str, int], int] | None = ...,
+    *,
+    limiter: CapacityLimiter | None = ...,
+) -> AsyncFile[bytes]: ...
+
+
+@overload
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: OpenTextMode = ...,
+    buffering: int = ...,
+    encoding: str | None = ...,
+    errors: str | None = ...,
+    newline: str | None = ...,
+    closefd: bool = ...,
+    opener: Callable[[str, int], int] | None = ...,
+    *,
+    limiter: CapacityLimiter | None = ...,
+) -> AsyncFile[str]: ...
+
+
+async def open_file(
+    file: str | PathLike[str] | int,
+    mode: str = "r",
+    buffering: int = -1,
+    encoding: str | None = None,
+    errors: str | None = None,
+    newline: str | None = None,
+    closefd: bool = True,
+    opener: Callable[[str, int], int] | None = None,
+    *,
+    limiter: CapacityLimiter | None = None,
+) -> AsyncFile[Any]:
+    """
+    Open a file asynchronously.
+
+    Except for ``limiter``, the arguments are exactly the same as for the builtin :func:`open`.
+
+    :param limiter: an optional capacity limiter to use with the file
+        instead of the default one
+    :return: an asynchronous file object
+
+    .. versionchanged:: 4.14.0
+        Added the ``limiter`` keyword argument.
+
+    """
+    fp = await to_thread.run_sync(
+        open,
+        file,
+        mode,
+        buffering,
+        encoding,
+        errors,
+        newline,
+        closefd,
+        opener,
+        limiter=limiter,
+    )
+    return AsyncFile(fp, limiter=limiter)
+
+
+def wrap_file(
+    file: IO[AnyStr], *, limiter: CapacityLimiter | None = None
+) -> AsyncFile[AnyStr]:
+    """
+    Wrap an existing file as an asynchronous file.
+
+    :param file: an existing file-like object
+    :param limiter: an optional capacity limiter to use with the file
+        instead of the default one
+    :return: an asynchronous file object
+
+    .. versionchanged:: 4.14.0
+        Added the ``limiter`` keyword argument.
+
+    """
+    return AsyncFile(file, limiter=limiter)
+
+
+@dataclass(eq=False)
+class _PathIterator(AsyncIterator[T]):
+    iterator: Iterator[PathLike[str]]
+    limiter: CapacityLimiter | None
+    # This was added to ensure that iterating over a subclass of Path yields instances
+    # of that subclass rather than the base Path class.
+    path_cls: type[T]
+
+    async def __anext__(self) -> T:
+        nextval = await to_thread.run_sync(
+            next, self.iterator, None, abandon_on_cancel=True, limiter=self.limiter
+        )
+        if nextval is None:
+            raise StopAsyncIteration from None
+
+        return self.path_cls(nextval, limiter=self.limiter)
+
+
+class Path:
+    """
+    An asynchronous version of :class:`pathlib.Path`.
+
+    This class cannot be substituted for :class:`pathlib.Path` or
+    :class:`pathlib.PurePath`, but it is compatible with the :class:`os.PathLike`
+    interface.
+
+    It implements the Python 3.10 version of :class:`pathlib.Path` interface, except for
+    the deprecated :meth:`~pathlib.Path.link_to` method.
+
+    Some methods may be unavailable or have limited functionality, based on the Python
+    version:
+
+    * :meth:`~pathlib.Path.copy` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.copy_into` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.from_uri` (available on Python 3.13 or later)
+    * :meth:`~pathlib.PurePath.full_match` (available on Python 3.13 or later)
+    * :attr:`~pathlib.Path.info` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.is_junction` (available on Python 3.12 or later)
+    * :meth:`~pathlib.PurePath.match` (the ``case_sensitive`` parameter is only
+      available on Python 3.13 or later)
+    * :meth:`~pathlib.Path.move` (available on Python 3.14 or later)
+    * :meth:`~pathlib.Path.move_into` (available on Python 3.14 or later)
+    * :meth:`~pathlib.PurePath.relative_to` (the ``walk_up`` parameter is only available
+      on Python 3.12 or later)
+    * :meth:`~pathlib.Path.walk` (available on Python 3.12 or later)
+
+    Any methods that do disk I/O need to be awaited on. These methods are:
+
+    * :meth:`~pathlib.Path.absolute`
+    * :meth:`~pathlib.Path.chmod`
+    * :meth:`~pathlib.Path.cwd`
+    * :meth:`~pathlib.Path.exists`
+    * :meth:`~pathlib.Path.expanduser`
+    * :meth:`~pathlib.Path.group`
+    * :meth:`~pathlib.Path.hardlink_to`
+    * :meth:`~pathlib.Path.home`
+    * :meth:`~pathlib.Path.is_block_device`
+    * :meth:`~pathlib.Path.is_char_device`
+    * :meth:`~pathlib.Path.is_dir`
+    * :meth:`~pathlib.Path.is_fifo`
+    * :meth:`~pathlib.Path.is_file`
+    * :meth:`~pathlib.Path.is_junction`
+    * :meth:`~pathlib.Path.is_mount`
+    * :meth:`~pathlib.Path.is_socket`
+    * :meth:`~pathlib.Path.is_symlink`
+    * :meth:`~pathlib.Path.lchmod`
+    * :meth:`~pathlib.Path.lstat`
+    * :meth:`~pathlib.Path.mkdir`
+    * :meth:`~pathlib.Path.open`
+    * :meth:`~pathlib.Path.owner`
+    * :meth:`~pathlib.Path.read_bytes`
+    * :meth:`~pathlib.Path.read_text`
+    * :meth:`~pathlib.Path.readlink`
+    * :meth:`~pathlib.Path.rename`
+    * :meth:`~pathlib.Path.replace`
+    * :meth:`~pathlib.Path.resolve`
+    * :meth:`~pathlib.Path.rmdir`
+    * :meth:`~pathlib.Path.samefile`
+    * :meth:`~pathlib.Path.stat`
+    * :meth:`~pathlib.Path.symlink_to`
+    * :meth:`~pathlib.Path.touch`
+    * :meth:`~pathlib.Path.unlink`
+    * :meth:`~pathlib.Path.walk`
+    * :meth:`~pathlib.Path.write_bytes`
+    * :meth:`~pathlib.Path.write_text`
+
+    Additionally, the following methods return an async iterator yielding
+    :class:`~.Path` objects:
+
+    * :meth:`~pathlib.Path.glob`
+    * :meth:`~pathlib.Path.iterdir`
+    * :meth:`~pathlib.Path.rglob`
+
+    .. versionchanged:: 4.14.0
+        Added the ``limiter`` keyword argument.
+    """
+
+    __slots__ = "__weakref__", "_limiter", "_path"
+
+    __weakref__: Any
+
+    def __init__(
+        self, *args: str | PathLike[str], limiter: CapacityLimiter | None = None
+    ) -> None:
+        if limiter is not None and not isinstance(limiter, CapacityLimiter):
+            raise TypeError(
+                f"limiter must be a CapacityLimiter or None, not "
+                f"{limiter.__class__.__name__}"
+            )
+
+        self._path: Final[pathlib.Path] = pathlib.Path(*args)
+        self._limiter = limiter
+
+    def __fspath__(self) -> str:
+        return self._path.__fspath__()
+
+    if sys.version_info >= (3, 15):
+
+        def __vfspath__(self) -> str:
+            return self._path.__vfspath__()
+
+    def __str__(self) -> str:
+        return self._path.__str__()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.as_posix()!r})"
+
+    def __bytes__(self) -> bytes:
+        return self._path.__bytes__()
+
+    def __hash__(self) -> int:
+        return self._path.__hash__()
+
+    def __eq__(self, other: object) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__eq__(target)
+
+    def __lt__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__lt__(target)
+
+    def __le__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__le__(target)
+
+    def __gt__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__gt__(target)
+
+    def __ge__(self, other: pathlib.PurePath | Path) -> bool:
+        target = other._path if isinstance(other, Path) else other
+        return self._path.__ge__(target)
+
+    def __truediv__(self, other: str | PathLike[str]) -> Self:
+        return type(self)(self._path / other, limiter=self._limiter)
+
+    def __rtruediv__(self, other: str | PathLike[str]) -> Self:
+        return type(self)(other, limiter=self._limiter) / self
+
+    @property
+    def limiter(self) -> CapacityLimiter | None:
+        """The capacity limiter used by this path, if not the global limiter."""
+        return self._limiter
+
+    @property
+    def parts(self) -> tuple[str, ...]:
+        return self._path.parts
+
+    @property
+    def drive(self) -> str:
+        return self._path.drive
+
+    @property
+    def root(self) -> str:
+        return self._path.root
+
+    @property
+    def anchor(self) -> str:
+        return self._path.anchor
+
+    @property
+    def parents(self) -> Sequence[Self]:
+        return tuple(type(self)(p, limiter=self._limiter) for p in self._path.parents)
+
+    @property
+    def parent(self) -> Self:
+        return type(self)(self._path.parent, limiter=self._limiter)
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    @property
+    def suffix(self) -> str:
+        return self._path.suffix
+
+    @property
+    def suffixes(self) -> list[str]:
+        return self._path.suffixes
+
+    @property
+    def stem(self) -> str:
+        return self._path.stem
+
+    async def absolute(self) -> Self:
+        path = await to_thread.run_sync(self._path.absolute, limiter=self._limiter)
+        return type(self)(path, limiter=self._limiter)
+
+    def as_posix(self) -> str:
+        return self._path.as_posix()
+
+    def as_uri(self) -> str:
+        return self._path.as_uri()
+
+    if sys.version_info >= (3, 13):
+        parser: ClassVar[ModuleType] = pathlib.Path.parser
+
+        @classmethod
+        def from_uri(cls, uri: str, *, limiter: CapacityLimiter | None = None) -> Self:
+            return cls(pathlib.Path.from_uri(uri), limiter=limiter)
+
+        def full_match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.full_match(path_pattern, case_sensitive=case_sensitive)
+
+        def match(
+            self, path_pattern: str, *, case_sensitive: bool | None = None
+        ) -> bool:
+            return self._path.match(path_pattern, case_sensitive=case_sensitive)
+    else:
+
+        def match(self, path_pattern: str) -> bool:
+            return self._path.match(path_pattern)
+
+    if sys.version_info >= (3, 14):
+
+        @property
+        def info(self) -> PathInfo:
+            return self._path.info
+
+        async def copy(
+            self,
+            target: str | os.PathLike[str],
+            *,
+            follow_symlinks: bool = True,
+            preserve_metadata: bool = False,
+        ) -> Self:
+            func = partial(
+                self._path.copy,
+                follow_symlinks=follow_symlinks,
+                preserve_metadata=preserve_metadata,
+            )
+            return type(self)(
+                await to_thread.run_sync(
+                    func, pathlib.Path(target), limiter=self._limiter
+                ),
+                limiter=self._limiter,
+            )
+
+        async def copy_into(
+            self,
+            target_dir: str | os.PathLike[str],
+            *,
+            follow_symlinks: bool = True,
+            preserve_metadata: bool = False,
+        ) -> Self:
+            func = partial(
+                self._path.copy_into,
+                follow_symlinks=follow_symlinks,
+                preserve_metadata=preserve_metadata,
+            )
+            return type(self)(
+                await to_thread.run_sync(
+                    func, pathlib.Path(target_dir), limiter=self._limiter
+                ),
+                limiter=self._limiter,
+            )
+
+        async def move(self, target: str | os.PathLike[str]) -> Self:
+            # Upstream does not handle anyio.Path properly as a PathLike
+            target = pathlib.Path(target)
+            return type(self)(
+                await to_thread.run_sync(
+                    self._path.move, target, limiter=self._limiter
+                ),
+                limiter=self._limiter,
+            )
+
+        async def move_into(
+            self,
+            target_dir: str | os.PathLike[str],
+        ) -> Self:
+            return type(self)(
+                await to_thread.run_sync(
+                    self._path.move_into, target_dir, limiter=self._limiter
+                ),
+                limiter=self._limiter,
+            )
+
+    def is_relative_to(self, other: str | PathLike[str]) -> bool:
+        try:
+            self.relative_to(other)
+            return True
+        except ValueError:
+            return False
+
+    async def chmod(self, mode: int, *, follow_symlinks: bool = True) -> None:
+        func = partial(os.chmod, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(func, self._path, mode, limiter=self._limiter)
+
+    @classmethod
+    async def cwd(cls, *, limiter: CapacityLimiter | None = None) -> Self:
+        path = await to_thread.run_sync(pathlib.Path.cwd, limiter=limiter)
+        return cls(path, limiter=limiter)
+
+    if sys.version_info >= (3, 12):
+
+        async def exists(self, *, follow_symlinks: bool = True) -> bool:
+            return await to_thread.run_sync(
+                partial(self._path.exists, follow_symlinks=follow_symlinks),
+                abandon_on_cancel=True,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def exists(self) -> bool:
+            return await to_thread.run_sync(
+                self._path.exists, abandon_on_cancel=True, limiter=self._limiter
+            )
+
+    async def expanduser(self) -> Self:
+        return type(self)(
+            await to_thread.run_sync(
+                self._path.expanduser, abandon_on_cancel=True, limiter=self._limiter
+            ),
+            limiter=self._limiter,
+        )
+
+    if sys.version_info < (3, 12):
+        # Python 3.11 and earlier
+        def glob(self, pattern: str) -> AsyncIterator[Self]:
+            gen = self._path.glob(pattern)
+            return _PathIterator(gen, self._limiter, type(self))
+    elif (3, 12) <= sys.version_info < (3, 13):
+        # changed in Python 3.12:
+        # - The case_sensitive parameter was added.
+        def glob(
+            self,
+            pattern: str,
+            *,
+            case_sensitive: bool | None = None,
+        ) -> AsyncIterator[Self]:
+            gen = self._path.glob(pattern, case_sensitive=case_sensitive)
+            return _PathIterator(gen, self._limiter, type(self))
+    elif sys.version_info >= (3, 13):
+        # Changed in Python 3.13:
+        # - The recurse_symlinks parameter was added.
+        # - The pattern parameter accepts a path-like object.
+        def glob(  # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block
+            self,
+            pattern: str | PathLike[str],
+            *,
+            case_sensitive: bool | None = None,
+            recurse_symlinks: bool = False,
+        ) -> AsyncIterator[Self]:
+            gen = self._path.glob(
+                pattern,  # type: ignore[arg-type]
+                case_sensitive=case_sensitive,
+                recurse_symlinks=recurse_symlinks,
+            )
+            return _PathIterator(gen, self._limiter, type(self))
+
+    if sys.version_info >= (3, 13):
+
+        async def group(self, *, follow_symlinks: bool = True) -> str:
+            return await to_thread.run_sync(
+                partial(self._path.group, follow_symlinks=follow_symlinks),
+                abandon_on_cancel=True,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def group(self) -> str:
+            return await to_thread.run_sync(
+                self._path.group, abandon_on_cancel=True, limiter=self._limiter
+            )
+
+    async def hardlink_to(
+        self, target: str | bytes | PathLike[str] | PathLike[bytes]
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(os.link, target, self, limiter=self._limiter)
+
+    @classmethod
+    async def home(cls, *, limiter: CapacityLimiter | None = None) -> Self:
+        home_path = await to_thread.run_sync(pathlib.Path.home, limiter=limiter)
+        return cls(home_path, limiter=limiter)
+
+    def is_absolute(self) -> bool:
+        return self._path.is_absolute()
+
+    async def is_block_device(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_block_device, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    async def is_char_device(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_char_device, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    if sys.version_info >= (3, 13):
+
+        async def is_dir(self, *, follow_symlinks: bool = True) -> bool:
+            return await to_thread.run_sync(
+                partial(self._path.is_dir, follow_symlinks=follow_symlinks),
+                abandon_on_cancel=True,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def is_dir(self) -> bool:
+            return await to_thread.run_sync(
+                self._path.is_dir, abandon_on_cancel=True, limiter=self._limiter
+            )
+
+    async def is_fifo(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_fifo, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    if sys.version_info >= (3, 13):
+
+        async def is_file(self, *, follow_symlinks: bool = True) -> bool:
+            return await to_thread.run_sync(
+                partial(self._path.is_file, follow_symlinks=follow_symlinks),
+                abandon_on_cancel=True,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def is_file(self) -> bool:
+            return await to_thread.run_sync(
+                self._path.is_file, abandon_on_cancel=True, limiter=self._limiter
+            )
+
+    if sys.version_info >= (3, 12):
+
+        async def is_junction(self) -> bool:
+            return await to_thread.run_sync(
+                self._path.is_junction, limiter=self._limiter
+            )
+
+    async def is_mount(self) -> bool:
+        return await to_thread.run_sync(
+            os.path.ismount, self._path, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    if sys.version_info < (3, 15):
+
+        def is_reserved(self) -> bool:
+            return self._path.is_reserved()
+
+    async def is_socket(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_socket, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    async def is_symlink(self) -> bool:
+        return await to_thread.run_sync(
+            self._path.is_symlink, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    async def iterdir(self) -> AsyncIterator[Self]:
+        gen = (
+            self._path.iterdir()
+            if sys.version_info < (3, 13)
+            else await to_thread.run_sync(
+                self._path.iterdir, abandon_on_cancel=True, limiter=self._limiter
+            )
+        )
+        async for path in _PathIterator(gen, self._limiter, type(self)):
+            yield path
+
+    def joinpath(self, *args: str | PathLike[str]) -> Self:
+        return type(self)(self._path.joinpath(*args), limiter=self._limiter)
+
+    async def lchmod(self, mode: int) -> None:
+        await to_thread.run_sync(self._path.lchmod, mode, limiter=self._limiter)
+
+    async def lstat(self) -> os.stat_result:
+        return await to_thread.run_sync(
+            self._path.lstat, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    async def mkdir(
+        self, mode: int = 0o777, parents: bool = False, exist_ok: bool = False
+    ) -> None:
+        await to_thread.run_sync(
+            self._path.mkdir, mode, parents, exist_ok, limiter=self._limiter
+        )
+
+    @overload
+    async def open(
+        self,
+        mode: OpenBinaryMode,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
+    ) -> AsyncFile[bytes]: ...
+
+    @overload
+    async def open(
+        self,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        errors: str | None = ...,
+        newline: str | None = ...,
+    ) -> AsyncFile[str]: ...
+
+    async def open(
+        self,
+        mode: str = "r",
+        buffering: int = -1,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> AsyncFile[Any]:
+        fp = await to_thread.run_sync(
+            self._path.open,
+            mode,
+            buffering,
+            encoding,
+            errors,
+            newline,
+            limiter=self._limiter,
+        )
+        return AsyncFile(fp, limiter=self._limiter)
+
+    if sys.version_info >= (3, 13):
+
+        async def owner(self, *, follow_symlinks: bool = True) -> str:
+            return await to_thread.run_sync(
+                partial(self._path.owner, follow_symlinks=follow_symlinks),
+                abandon_on_cancel=True,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def owner(self) -> str:
+            return await to_thread.run_sync(
+                self._path.owner, abandon_on_cancel=True, limiter=self._limiter
+            )
+
+    async def read_bytes(self) -> bytes:
+        return await to_thread.run_sync(self._path.read_bytes, limiter=self._limiter)
+
+    if sys.version_info >= (3, 13):
+
+        async def read_text(
+            self,
+            encoding: str | None = None,
+            errors: str | None = None,
+            newline: str | None = None,
+        ) -> str:
+            return await to_thread.run_sync(
+                self._path.read_text,
+                encoding,
+                errors,
+                newline,
+                limiter=self._limiter,
+            )
+
+    else:
+
+        async def read_text(
+            self, encoding: str | None = None, errors: str | None = None
+        ) -> str:
+            return await to_thread.run_sync(
+                self._path.read_text, encoding, errors, limiter=self._limiter
+            )
+
+    if sys.version_info >= (3, 12):
+
+        def relative_to(
+            self, *other: str | PathLike[str], walk_up: bool = False
+        ) -> Self:
+            # relative_to() should work with any PathLike but it doesn't
+            others = [pathlib.Path(other) for other in other]
+            return type(self)(
+                self._path.relative_to(*others, walk_up=walk_up), limiter=self._limiter
+            )
+
+    else:
+
+        def relative_to(self, *other: str | PathLike[str]) -> Self:
+            return type(self)(self._path.relative_to(*other), limiter=self._limiter)
+
+    async def readlink(self) -> Self:
+        target = await to_thread.run_sync(
+            os.readlink, self._path, limiter=self._limiter
+        )
+        return type(self)(target, limiter=self._limiter)
+
+    async def rename(self, target: str | pathlib.PurePath | Path) -> Self:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.rename, target, limiter=self._limiter)
+        return type(self)(target, limiter=self._limiter)
+
+    async def replace(self, target: str | pathlib.PurePath | Path) -> Self:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(self._path.replace, target, limiter=self._limiter)
+        return type(self)(target, limiter=self._limiter)
+
+    async def resolve(self, strict: bool = False) -> Self:
+        func = partial(self._path.resolve, strict=strict)
+        return type(self)(
+            await to_thread.run_sync(
+                func, abandon_on_cancel=True, limiter=self._limiter
+            ),
+            limiter=self._limiter,
+        )
+
+    if sys.version_info < (3, 12):
+        # Pre Python 3.12
+        def rglob(self, pattern: str) -> AsyncIterator[Self]:
+            gen = self._path.rglob(pattern)
+            return _PathIterator(gen, self._limiter, type(self))
+    elif (3, 12) <= sys.version_info < (3, 13):
+        # Changed in Python 3.12:
+        # - The case_sensitive parameter was added.
+        def rglob(
+            self, pattern: str, *, case_sensitive: bool | None = None
+        ) -> AsyncIterator[Self]:
+            gen = self._path.rglob(pattern, case_sensitive=case_sensitive)
+            return _PathIterator(gen, self._limiter, type(self))
+    elif sys.version_info >= (3, 13):
+        # Changed in Python 3.13:
+        # - The recurse_symlinks parameter was added.
+        # - The pattern parameter accepts a path-like object.
+        def rglob(  # type: ignore[misc] # mypy doesn't allow for differing signatures in a conditional block
+            self,
+            pattern: str | PathLike[str],
+            *,
+            case_sensitive: bool | None = None,
+            recurse_symlinks: bool = False,
+        ) -> AsyncIterator[Self]:
+            gen = self._path.rglob(
+                pattern,  # type: ignore[arg-type]
+                case_sensitive=case_sensitive,
+                recurse_symlinks=recurse_symlinks,
+            )
+            return _PathIterator(gen, self._limiter, type(self))
+
+    async def rmdir(self) -> None:
+        await to_thread.run_sync(self._path.rmdir, limiter=self._limiter)
+
+    async def samefile(self, other_path: str | PathLike[str]) -> bool:
+        if isinstance(other_path, Path):
+            other_path = other_path._path
+
+        return await to_thread.run_sync(
+            self._path.samefile,
+            other_path,
+            abandon_on_cancel=True,
+            limiter=self._limiter,
+        )
+
+    async def stat(self, *, follow_symlinks: bool = True) -> os.stat_result:
+        func = partial(os.stat, follow_symlinks=follow_symlinks)
+        return await to_thread.run_sync(
+            func, self._path, abandon_on_cancel=True, limiter=self._limiter
+        )
+
+    async def symlink_to(
+        self,
+        target: str | bytes | PathLike[str] | PathLike[bytes],
+        target_is_directory: bool = False,
+    ) -> None:
+        if isinstance(target, Path):
+            target = target._path
+
+        await to_thread.run_sync(
+            self._path.symlink_to, target, target_is_directory, limiter=self._limiter
+        )
+
+    async def touch(self, mode: int = 0o666, exist_ok: bool = True) -> None:
+        await to_thread.run_sync(
+            self._path.touch, mode, exist_ok, limiter=self._limiter
+        )
+
+    async def unlink(self, missing_ok: bool = False) -> None:
+        try:
+            await to_thread.run_sync(self._path.unlink, limiter=self._limiter)
+        except FileNotFoundError:
+            if not missing_ok:
+                raise
+
+    if sys.version_info >= (3, 12):
+
+        async def walk(
+            self,
+            top_down: bool = True,
+            on_error: Callable[[OSError], object] | None = None,
+            follow_symlinks: bool = False,
+        ) -> AsyncIterator[tuple[Self, list[str], list[str]]]:
+            def get_next_value() -> tuple[pathlib.Path, list[str], list[str]] | None:
+                try:
+                    return next(gen)
+                except StopIteration:
+                    return None
+
+            gen = self._path.walk(top_down, on_error, follow_symlinks)
+            while True:
+                value = await to_thread.run_sync(get_next_value, limiter=self._limiter)
+                if value is None:
+                    return
+
+                root, dirs, paths = value
+                yield type(self)(root, limiter=self._limiter), dirs, paths
+
+    def with_name(self, name: str) -> Self:
+        return type(self)(self._path.with_name(name), limiter=self._limiter)
+
+    if sys.version_info < (3, 13):
+        # Backport pathlib's Python>=3.13 behavior for empty stems on paths with non-empty suffixes.
+        # See: https://github.com/python/cpython/pull/114612
+        def with_stem(self, stem: str) -> Self:
+            suffix = self._path.suffix
+            if not suffix:
+                return self.with_name(stem)
+            elif not stem:
+                # If the suffix is non-empty, we can't make the stem empty.
+                raise ValueError(f"{self!r} has a non-empty suffix")
+            else:
+                return self.with_name(stem + suffix)
+    else:
+
+        def with_stem(self, stem: str) -> Self:
+            return type(self)(self._path.with_stem(stem), limiter=self._limiter)
+
+    def with_suffix(self, suffix: str) -> Self:
+        return type(self)(self._path.with_suffix(suffix), limiter=self._limiter)
+
+    def with_segments(self, *pathsegments: str | PathLike[str]) -> Self:
+        return type(self)(*pathsegments, limiter=self._limiter)
+
+    async def write_bytes(self, data: ReadableBuffer) -> int:
+        return await to_thread.run_sync(
+            self._path.write_bytes, data, limiter=self._limiter
+        )
+
+    async def write_text(
+        self,
+        data: str,
+        encoding: str | None = None,
+        errors: str | None = None,
+        newline: str | None = None,
+    ) -> int:
+        return await to_thread.run_sync(
+            self._path.write_text,
+            data,
+            encoding,
+            errors,
+            newline,
+            limiter=self._limiter,
+        )
+
+
+PathLike.register(Path)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_futures.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_futures.py
new file mode 100644
index 0000000000000000000000000000000000000000..7730c53c7f9bf55742396fa26fa7dd054cdfcb18
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_futures.py
@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from enum import Enum, auto
+from typing import Any, Generic, TypeVar
+
+from ._exceptions import (
+    FutureAlreadyFinished,
+    FutureCancelled,
+    FutureFailed,
+    FutureNotFinished,
+)
+from ._synchronization import Event
+
+T = TypeVar("T")
+
+
+class Future(Generic[T]):
+    """
+    An awaitable object that works similar to a :class:`asyncio.Future` but
+    with similar characteristics to a :class:`.TaskHandle`.
+    """
+
+    class Status(Enum):
+        """
+        The status of a future handle.
+
+        .. attribute:: PENDING
+
+            The future has not finished yet.
+        .. attribute:: FINISHED
+
+            The future has finished with a return value.
+        .. attribute:: CANCELLED
+
+            The future was cancelled and has finished since.
+        .. attribute:: FAILED
+
+            The future raised an exception.
+        """
+
+        PENDING = auto()
+        FINISHED = auto()
+        CANCELLED = auto()
+        FAILED = auto()
+
+    __slots__ = (
+        "_cancelled",
+        "_exception",
+        "_finished_event",
+        "_name",
+        "_return_value",
+    )
+    _return_value: T
+
+    def __init__(self, *, name: str | None = None) -> None:
+        self._finished_event = Event()
+        self._exception: BaseException | None = None
+        self._cancelled: bool = False
+        self._name = name
+
+    def _check_pending(self) -> None:
+        """Shortcut for checking if a Future is pending
+
+        :raises FutureAlreadyFinished: if future was already given a result or exception.
+        :raises FutureCancelled: if future has been cancelled previously.
+        """
+        match self.status:
+            case Future.Status.PENDING:
+                return
+            case Future.Status.FINISHED:
+                raise FutureAlreadyFinished("future has already finished")
+            case Future.Status.FAILED:
+                raise FutureAlreadyFinished("future already failed")
+            case Future.Status.CANCELLED:
+                raise FutureCancelled("future was cancelled")
+
+    async def wait(self) -> None:
+        """
+        Waits for the future to finish.
+
+        This method will attempt to wait for a result or exception
+        """
+        await self._finished_event.wait()
+
+    def cancel(self) -> None:
+        """Cancels a pending `.Future` object
+
+        Does nothing if the Future was already finished.
+        """
+        if self.status is Future.Status.PENDING:
+            self._cancelled = True
+            self._finished_event.set()
+
+    @property
+    def exception(self) -> BaseException | None:
+        """
+        The exception value of a `.Future`
+
+        :raises FutureNotFinished: if future is still pending
+        :raises FutureCancelled: if future was cancelled
+        :returns: None if future succeeds with a result sent instead
+            otherwise this will be an exception
+        """
+
+        match self.status:
+            case Future.Status.PENDING:
+                raise FutureNotFinished("the future has not finished yet")
+            case Future.Status.FINISHED:
+                return None
+            case Future.Status.CANCELLED:
+                raise FutureCancelled("the future was cancelled")
+            case Future.Status.FAILED:
+                return self._exception
+
+    @exception.setter
+    def exception(self, exception: BaseException) -> None:
+        """Send exception for a `.Future` object
+
+        :raises FutureAlreadyFinished: if future was already given a result or exception.
+        :raises FutureCancelled: if future has been cancelled previously.
+        """
+        self._check_pending()
+        self._exception = exception
+        self._finished_event.set()
+
+    @property
+    def return_value(self) -> T:
+        """
+        The return value of the future.
+
+        :raises FutureNotFinished: if the future has not finished yet
+        :raises FutureCancelled: if the future was cancelled
+        :raises FutureFailed: if the future raised an exception
+
+        """
+        match self.status:
+            case Future.Status.PENDING:
+                raise FutureNotFinished("the future has not finished yet")
+            case Future.Status.FINISHED:
+                return self._return_value
+            case Future.Status.CANCELLED:
+                raise FutureCancelled("the future was cancelled")
+            case Future.Status.FAILED:
+                raise FutureFailed(
+                    "the future raised an exception"
+                ) from self._exception
+
+    @return_value.setter
+    def return_value(self, value: T) -> None:
+        """
+        Send pending result for a `.Future` object
+
+        :raises FutureAlreadyFinished: if future was already given a result or exception.
+        :raises FutureCancelled: if future has been cancelled previously.
+        """
+        self._check_pending()
+        self._return_value = value
+        self._finished_event.set()
+
+    @property
+    def status(self) -> Future.Status:
+        """
+        The current status of a future.
+
+        Every future starts in the :attr:`~Future.Status.PENDING` state.
+        If a future is cancelled while in this state, it will transition to the
+        :attr:`Future.Status.CANCELLED` state. When the task finishes, it will
+        transition to one of the three final states (
+        :attr:`Future.Status.FINISHED`, :attr:`Future.Status.FAILED`, or
+        :attr:`Future.Status.CANCELLED`) depending on the exception the task
+        raised, if any. No other status transitions will happen.
+        """
+        if not self._finished_event.is_set():
+            return Future.Status.PENDING
+        elif self._cancelled:
+            return Future.Status.CANCELLED
+        elif self._exception is not None:
+            return Future.Status.FAILED
+        else:
+            return Future.Status.FINISHED
+
+    def __await__(self) -> Generator[Any, Any, T]:
+        yield from self.wait().__await__()
+        return self.return_value
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__name__} {self.status.name.lower()} "
+            f"name={self._name!r}>"
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_resources.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_resources.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ca35d94a930661c4c976c204cfb6b31cc15be37
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_resources.py
@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from ..abc import AsyncResource  # noqa: TC001
+from ._tasks import CancelScope
+
+
+async def aclose_forcefully(resource: AsyncResource) -> None:
+    """
+    Close an asynchronous resource in a cancelled scope.
+
+    Doing this closes the resource without waiting on anything.
+
+    :param resource: the resource to close
+
+    """
+    with CancelScope() as scope:
+        scope.cancel()
+        await resource.aclose()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_signals.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_signals.py
new file mode 100644
index 0000000000000000000000000000000000000000..e24c79e10d4b76775679f7dd0dbe3f5860150451
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_signals.py
@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import AbstractContextManager
+from signal import Signals
+
+from ._eventloop import get_async_backend
+
+
+def open_signal_receiver(
+    *signals: Signals,
+) -> AbstractContextManager[AsyncIterator[Signals]]:
+    """
+    Start receiving operating system signals.
+
+    :param signals: signals to receive (e.g. ``signal.SIGINT``)
+    :return: an asynchronous context manager for an asynchronous iterator which yields
+        signal numbers
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. warning:: Windows does not support signals natively so it is best to avoid
+        relying on this in cross-platform applications.
+
+    .. warning:: On asyncio, this permanently replaces any previous signal handler for
+        the given signals, as set via :meth:`~asyncio.loop.add_signal_handler`.
+
+    """
+    return get_async_backend().open_signal_receiver(*signals)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_sockets.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_sockets.py
new file mode 100644
index 0000000000000000000000000000000000000000..14ee6e41e79f5a839b7bcf97dd3ca5e3ae656f49
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_sockets.py
@@ -0,0 +1,1011 @@
+from __future__ import annotations
+
+import errno
+import os
+import socket
+import ssl
+import stat
+import sys
+from collections.abc import Awaitable
+from dataclasses import dataclass
+from ipaddress import IPv4Address, IPv6Address, ip_address
+from os import PathLike, chmod
+from socket import AddressFamily, SocketKind
+from typing import TYPE_CHECKING, Any, Literal, cast, overload
+
+from .. import ConnectionFailed, to_thread
+from ..abc import (
+    ByteStreamConnectable,
+    ConnectedUDPSocket,
+    ConnectedUNIXDatagramSocket,
+    IPAddressType,
+    IPSockAddrType,
+    SocketListener,
+    SocketStream,
+    UDPSocket,
+    UNIXDatagramSocket,
+    UNIXSocketStream,
+)
+from ..streams.stapled import MultiListener
+from ..streams.tls import TLSConnectable, TLSStream
+from ._eventloop import get_async_backend
+from ._resources import aclose_forcefully
+from ._synchronization import Event
+from ._tasks import create_task_group, move_on_after
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+else:
+    FileDescriptorLike = object
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+if sys.version_info < (3, 13):
+    from typing_extensions import deprecated
+else:
+    from warnings import deprecated
+
+IPPROTO_IPV6 = getattr(socket, "IPPROTO_IPV6", 41)  # https://bugs.python.org/issue29515
+
+AnyIPAddressFamily = Literal[
+    AddressFamily.AF_UNSPEC, AddressFamily.AF_INET, AddressFamily.AF_INET6
+]
+IPAddressFamily = Literal[AddressFamily.AF_INET, AddressFamily.AF_INET6]
+
+
+def idna2008_resolve(host: str) -> bytes:
+    try:
+        return host.encode("ascii")
+    except UnicodeEncodeError:
+        import idna
+
+        return idna.encode(host, uts46=True)
+
+
+# tls_hostname given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = ...,
+    local_port: int | None = ...,
+    ssl_context: ssl.SSLContext | None = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream: ...
+
+
+# ssl_context given
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = ...,
+    local_port: int | None = ...,
+    ssl_context: ssl.SSLContext,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str | None = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream: ...
+
+
+# tls=True
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = ...,
+    local_port: int | None = ...,
+    tls: Literal[True],
+    ssl_context: ssl.SSLContext | None = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str | None = ...,
+    happy_eyeballs_delay: float = ...,
+) -> TLSStream: ...
+
+
+# tls=False
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = ...,
+    local_port: int | None = ...,
+    tls: Literal[False],
+    ssl_context: ssl.SSLContext | None = ...,
+    tls_standard_compatible: bool = ...,
+    tls_hostname: str | None = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream: ...
+
+
+# No TLS arguments
+@overload
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = ...,
+    local_port: int | None = ...,
+    happy_eyeballs_delay: float = ...,
+) -> SocketStream: ...
+
+
+async def connect_tcp(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    local_host: IPAddressType | None = None,
+    local_port: int | None = None,
+    tls: bool = False,
+    ssl_context: ssl.SSLContext | None = None,
+    tls_standard_compatible: bool = True,
+    tls_hostname: str | None = None,
+    happy_eyeballs_delay: float = 0.25,
+) -> SocketStream | TLSStream:
+    """
+    Connect to a host using the TCP protocol.
+
+    This function implements the stateless version of the Happy Eyeballs algorithm (RFC
+    6555). If ``remote_host`` is a host name that resolves to multiple IP addresses,
+    each one is tried until one connection attempt succeeds. If the first attempt does
+    not connected within 250 milliseconds, a second attempt is started using the next
+    address in the list, and so on. On IPv6 enabled systems, an IPv6 address (if
+    available) is tried first.
+
+    When the connection has been established, a TLS handshake will be done if either
+    ``ssl_context`` or ``tls_hostname`` is not ``None``, or if ``tls`` is ``True``.
+
+    :param remote_host: the IP address or host name to connect to
+    :param remote_port: port on the target host to connect to
+    :param local_host: the interface address or name to bind the socket to before
+        connecting
+    :param local_port: the local port to bind to (requires ``local_host`` to also be
+        set)
+    :param tls: ``True`` to do a TLS handshake with the connected stream and return a
+        :class:`~anyio.streams.tls.TLSStream` instead
+    :param ssl_context: the SSL context object to use (if omitted, a default context is
+        created)
+    :param tls_standard_compatible: If ``True``, performs the TLS shutdown handshake
+        before closing the stream and requires that the server does this as well.
+        Otherwise, :exc:`~ssl.SSLEOFError` may be raised during reads from the stream.
+        Some protocols, such as HTTP, require this option to be ``False``.
+        See :meth:`~ssl.SSLContext.wrap_socket` for details.
+    :param tls_hostname: host name to check the server certificate against (defaults to
+        the value of ``remote_host``)
+    :param happy_eyeballs_delay: delay (in seconds) before starting the next connection
+        attempt
+    :return: a socket stream object if no TLS handshake was done, otherwise a TLS stream
+    :raises ConnectionFailed: if the connection fails
+
+    """
+    # Placed here due to https://github.com/python/mypy/issues/7057
+    connected_stream: SocketStream | None = None
+
+    async def try_connect(remote_host: str, event: Event) -> None:
+        nonlocal connected_stream
+        try:
+            stream = await asynclib.connect_tcp(remote_host, remote_port, local_address)
+        except OSError as exc:
+            oserrors.append(exc)
+            return
+        else:
+            if connected_stream is None:
+                connected_stream = stream
+                tg.cancel_scope.cancel()
+            else:
+                await stream.aclose()
+        finally:
+            event.set()
+
+    asynclib = get_async_backend()
+    local_address: IPSockAddrType | None = None
+    family = socket.AF_UNSPEC
+    if local_host:
+        gai_res = await getaddrinfo(str(local_host), local_port)
+        family, *_, local_address = gai_res[0]
+
+    target_host = str(remote_host)
+    try:
+        addr_obj = ip_address(remote_host)
+    except ValueError:
+        addr_obj = None
+
+    if addr_obj is not None:
+        if isinstance(addr_obj, IPv6Address):
+            target_addrs = [(socket.AF_INET6, addr_obj.compressed)]
+        else:
+            target_addrs = [(socket.AF_INET, addr_obj.compressed)]
+    else:
+        # getaddrinfo() will raise an exception if name resolution fails
+        gai_res = await getaddrinfo(
+            target_host, remote_port, family=family, type=socket.SOCK_STREAM
+        )
+
+        # Organize the list so that the first address is an IPv6 address (if available)
+        # and the second one is an IPv4 addresses. The rest can be in whatever order.
+        v6_found = v4_found = False
+        target_addrs = []
+        for af, *_, sa in gai_res:
+            if af == socket.AF_INET6 and not v6_found:
+                v6_found = True
+                target_addrs.insert(0, (af, sa[0]))
+            elif af == socket.AF_INET and not v4_found and v6_found:
+                v4_found = True
+                target_addrs.insert(1, (af, sa[0]))
+            else:
+                target_addrs.append((af, sa[0]))
+
+    oserrors: list[OSError] = []
+    try:
+        async with create_task_group() as tg:
+            for _af, addr in target_addrs:
+                event = Event()
+                tg.start_soon(try_connect, addr, event)
+                with move_on_after(happy_eyeballs_delay):
+                    await event.wait()
+
+        if connected_stream is None:
+            cause = (
+                oserrors[0]
+                if len(oserrors) == 1
+                else ExceptionGroup("multiple connection attempts failed", oserrors)
+            )
+            raise OSError("All connection attempts failed") from cause
+    finally:
+        oserrors.clear()
+
+    if tls or tls_hostname or ssl_context:
+        try:
+            return await TLSStream.wrap(
+                connected_stream,
+                server_side=False,
+                hostname=tls_hostname or str(remote_host),
+                ssl_context=ssl_context,
+                standard_compatible=tls_standard_compatible,
+            )
+        except BaseException:
+            await aclose_forcefully(connected_stream)
+            raise
+
+    return connected_stream
+
+
+async def connect_unix(path: str | bytes | PathLike[Any]) -> UNIXSocketStream:
+    """
+    Connect to the given UNIX socket.
+
+    Not available on Windows.
+
+    :param path: path to the socket
+    :return: a socket stream object
+    :raises ConnectionFailed: if the connection fails
+
+    """
+    path = os.fspath(path)
+    return await get_async_backend().connect_unix(path)
+
+
+async def create_tcp_listener(
+    *,
+    local_host: IPAddressType | None = None,
+    local_port: int = 0,
+    family: AnyIPAddressFamily = socket.AddressFamily.AF_UNSPEC,
+    backlog: int = 65536,
+    reuse_port: bool = False,
+) -> MultiListener[SocketStream]:
+    """
+    Create a TCP socket listener.
+
+    :param local_port: port number to listen on
+    :param local_host: IP address of the interface to listen on. If omitted, listen on
+        all IPv4 and IPv6 interfaces. To listen on all interfaces on a specific address
+        family, use ``0.0.0.0`` for IPv4 or ``::`` for IPv6.
+    :param family: address family (used if ``local_host`` was omitted)
+    :param backlog: maximum number of queued incoming connections (up to a maximum of
+        2**16, or 65536)
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
+    :return: a multi-listener object containing one or more socket listeners
+    :raises OSError: if there's an error creating a socket, or binding to one or more
+        interfaces failed
+
+    """
+    asynclib = get_async_backend()
+    backlog = min(backlog, 65536)
+    local_host = str(local_host) if local_host is not None else None
+
+    def setup_raw_socket(
+        fam: AddressFamily,
+        bind_addr: tuple[str, int] | tuple[str, int, int, int],
+        *,
+        v6only: bool = True,
+    ) -> socket.socket:
+        sock = socket.socket(fam)
+        try:
+            sock.setblocking(False)
+
+            if fam == AddressFamily.AF_INET6:
+                sock.setsockopt(IPPROTO_IPV6, socket.IPV6_V6ONLY, v6only)
+
+            # For Windows, enable exclusive address use. For others, enable address
+            # reuse.
+            if sys.platform == "win32":
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_EXCLUSIVEADDRUSE, 1)
+            else:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+            if reuse_port:
+                sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+
+            # Workaround for #554
+            if fam == socket.AF_INET6 and "%" in bind_addr[0]:
+                addr, scope_id = bind_addr[0].split("%", 1)
+                bind_addr = (addr, bind_addr[1], 0, int(scope_id))
+
+            sock.bind(bind_addr)
+            sock.listen(backlog)
+        except BaseException:
+            sock.close()
+            raise
+
+        return sock
+
+    # We passing type=0 on non-Windows platforms as a workaround for a uvloop bug
+    # where we don't get the correct scope ID for IPv6 link-local addresses when passing
+    # type=socket.SOCK_STREAM to getaddrinfo():
+    # https://github.com/MagicStack/uvloop/issues/539
+    gai_res = await getaddrinfo(
+        local_host,
+        local_port,
+        family=family,
+        type=socket.SOCK_STREAM if sys.platform == "win32" else 0,
+        flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+    )
+
+    # The set comprehension is here to work around a glibc bug:
+    # https://sourceware.org/bugzilla/show_bug.cgi?id=14969
+    sockaddrs = sorted({res for res in gai_res if res[1] == SocketKind.SOCK_STREAM})
+
+    # Special case for dual-stack binding on the "any" interface
+    if (
+        local_host is None
+        and family == AddressFamily.AF_UNSPEC
+        and socket.has_dualstack_ipv6()
+        and any(fam == AddressFamily.AF_INET6 for fam, *_ in gai_res)
+    ):
+        raw_socket = setup_raw_socket(
+            AddressFamily.AF_INET6, ("::", local_port), v6only=False
+        )
+        listener = asynclib.create_tcp_listener(raw_socket)
+        return MultiListener([listener])
+
+    errors: list[OSError] = []
+    try:
+        for _ in range(len(sockaddrs)):
+            listeners: list[SocketListener] = []
+            bound_ephemeral_port = local_port
+            try:
+                for fam, *_, sockaddr in sockaddrs:
+                    sockaddr = sockaddr[0], bound_ephemeral_port, *sockaddr[2:]
+                    raw_socket = setup_raw_socket(fam, sockaddr)
+
+                    # Store the assigned port if an ephemeral port was requested, so
+                    # we'll bind to the same port on all interfaces
+                    if local_port == 0 and len(gai_res) > 1:
+                        bound_ephemeral_port = raw_socket.getsockname()[1]
+
+                    listeners.append(asynclib.create_tcp_listener(raw_socket))
+            except BaseException as exc:
+                for listener in listeners:
+                    await listener.aclose()
+
+                # If an ephemeral port was requested but binding the assigned port
+                # failed for another interface, rotate the address list and try again
+                if (
+                    isinstance(exc, OSError)
+                    and exc.errno == errno.EADDRINUSE
+                    and local_port == 0
+                    and bound_ephemeral_port
+                ):
+                    errors.append(exc)
+                    sockaddrs.append(sockaddrs.pop(0))
+                    continue
+
+                raise
+
+            return MultiListener(listeners)
+
+        raise OSError(
+            f"Could not create {len(sockaddrs)} listeners with a consistent port"
+        ) from ExceptionGroup("Several bind attempts failed", errors)
+    finally:
+        del errors  # Prevent reference cycles
+
+
+async def create_unix_listener(
+    path: str | bytes | PathLike[Any],
+    *,
+    mode: int | None = None,
+    backlog: int = 65536,
+) -> SocketListener:
+    """
+    Create a UNIX socket listener.
+
+    Not available on Windows.
+
+    :param path: path of the socket
+    :param mode: permissions to set on the socket
+    :param backlog: maximum number of queued incoming connections (up to a maximum of
+        2**16, or 65536)
+    :return: a listener object
+
+    .. versionchanged:: 3.0
+        If a socket already exists on the file system in the given path, it will be
+        removed first.
+
+    """
+    backlog = min(backlog, 65536)
+    raw_socket = await setup_unix_local_socket(path, mode, socket.SOCK_STREAM)
+    try:
+        raw_socket.listen(backlog)
+        return get_async_backend().create_unix_listener(raw_socket)
+    except BaseException:
+        raw_socket.close()
+        raise
+
+
+async def create_udp_socket(
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    *,
+    local_host: IPAddressType | None = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> UDPSocket:
+    """
+    Create a UDP socket.
+
+    If ``port`` has been given, the socket will be bound to this port on the local
+    machine, making this socket suitable for providing UDP based services.
+
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically
+        determined from ``local_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
+    :return: a UDP socket
+
+    """
+    if family is AddressFamily.AF_UNSPEC and not local_host:
+        raise ValueError('Either "family" or "local_host" must be given')
+
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+    elif family is AddressFamily.AF_INET6:
+        local_address = ("::", 0)
+    else:
+        local_address = ("0.0.0.0", 0)
+
+    sock = await get_async_backend().create_udp_socket(
+        family, local_address, None, reuse_port
+    )
+    return cast(UDPSocket, sock)
+
+
+async def create_connected_udp_socket(
+    remote_host: IPAddressType,
+    remote_port: int,
+    *,
+    family: AnyIPAddressFamily = AddressFamily.AF_UNSPEC,
+    local_host: IPAddressType | None = None,
+    local_port: int = 0,
+    reuse_port: bool = False,
+) -> ConnectedUDPSocket:
+    """
+    Create a connected UDP socket.
+
+    Connected UDP sockets can only communicate with the specified remote host/port, an
+    any packets sent from other sources are dropped.
+
+    :param remote_host: remote host to set as the default target
+    :param remote_port: port on the remote host to set as the default target
+    :param family: address family (``AF_INET`` or ``AF_INET6``) – automatically
+        determined from ``local_host`` or ``remote_host`` if omitted
+    :param local_host: IP address or host name of the local interface to bind to
+    :param local_port: local port to bind to
+    :param reuse_port: ``True`` to allow multiple sockets to bind to the same
+        address/port (not supported on Windows)
+    :return: a connected UDP socket
+
+    """
+    local_address = None
+    if local_host:
+        gai_res = await getaddrinfo(
+            str(local_host),
+            local_port,
+            family=family,
+            type=socket.SOCK_DGRAM,
+            flags=socket.AI_PASSIVE | socket.AI_ADDRCONFIG,
+        )
+        family = cast(AnyIPAddressFamily, gai_res[0][0])
+        local_address = gai_res[0][-1]
+
+    gai_res = await getaddrinfo(
+        str(remote_host), remote_port, family=family, type=socket.SOCK_DGRAM
+    )
+    family = cast(AnyIPAddressFamily, gai_res[0][0])
+    remote_address = gai_res[0][-1]
+
+    sock = await get_async_backend().create_udp_socket(
+        family, local_address, remote_address, reuse_port
+    )
+    return cast(ConnectedUDPSocket, sock)
+
+
+async def create_unix_datagram_socket(
+    *,
+    local_path: None | str | bytes | PathLike[Any] = None,
+    local_mode: int | None = None,
+) -> UNIXDatagramSocket:
+    """
+    Create a UNIX datagram socket.
+
+    Not available on Windows.
+
+    If ``local_path`` has been given, the socket will be bound to this path, making this
+    socket suitable for receiving datagrams from other processes. Other processes can
+    send datagrams to this socket only if ``local_path`` is set.
+
+    If a socket already exists on the file system in the ``local_path``, it will be
+    removed first.
+
+    :param local_path: the path on which to bind to
+    :param local_mode: permissions to set on the local socket
+    :return: a UNIX datagram socket
+
+    """
+    raw_socket = await setup_unix_local_socket(
+        local_path, local_mode, socket.SOCK_DGRAM
+    )
+    return await get_async_backend().create_unix_datagram_socket(raw_socket, None)
+
+
+async def create_connected_unix_datagram_socket(
+    remote_path: str | bytes | PathLike[Any],
+    *,
+    local_path: None | str | bytes | PathLike[Any] = None,
+    local_mode: int | None = None,
+) -> ConnectedUNIXDatagramSocket:
+    """
+    Create a connected UNIX datagram socket.
+
+    Connected datagram sockets can only communicate with the specified remote path.
+
+    If ``local_path`` has been given, the socket will be bound to this path, making
+    this socket suitable for receiving datagrams from other processes. Other processes
+    can send datagrams to this socket only if ``local_path`` is set.
+
+    If a socket already exists on the file system in the ``local_path``, it will be
+    removed first.
+
+    :param remote_path: the path to set as the default target
+    :param local_path: the path on which to bind to
+    :param local_mode: permissions to set on the local socket
+    :return: a connected UNIX datagram socket
+
+    """
+    remote_path = os.fspath(remote_path)
+    raw_socket = await setup_unix_local_socket(
+        local_path, local_mode, socket.SOCK_DGRAM
+    )
+    return await get_async_backend().create_unix_datagram_socket(
+        raw_socket, remote_path
+    )
+
+
+async def getaddrinfo(
+    host: bytes | str | None,
+    port: str | int | None,
+    *,
+    family: int | AddressFamily = 0,
+    type: int | SocketKind = 0,
+    proto: int = 0,
+    flags: int = 0,
+) -> list[tuple[AddressFamily, SocketKind, int, str, tuple[str, int]]]:
+    """
+    Look up a numeric IP address given a host name.
+
+    Internationalized domain names are translated according to the (non-transitional)
+    IDNA 2008 standard.
+
+    .. note:: 4-tuple IPv6 socket addresses are automatically converted to 2-tuples of
+        (host, port), unlike what :func:`socket.getaddrinfo` does.
+
+    :param host: host name
+    :param port: port number
+    :param family: socket family (`'AF_INET``, ...)
+    :param type: socket type (``SOCK_STREAM``, ...)
+    :param proto: protocol number
+    :param flags: flags to pass to upstream ``getaddrinfo()``
+    :return: list of tuples containing (family, type, proto, canonname, sockaddr)
+
+    .. seealso:: :func:`socket.getaddrinfo`
+
+    """
+    # Handle unicode hostnames
+    encoded_host = idna2008_resolve(host) if isinstance(host, str) else host
+    gai_res = await get_async_backend().getaddrinfo(
+        encoded_host, port, family=family, type=type, proto=proto, flags=flags
+    )
+    return [
+        (family, type, proto, canonname, convert_ipv6_sockaddr(sockaddr))
+        for family, type, proto, canonname, sockaddr in gai_res
+        # filter out IPv6 results when IPv6 is disabled
+        if not isinstance(sockaddr[0], int)
+    ]
+
+
+def getnameinfo(sockaddr: IPSockAddrType, flags: int = 0) -> Awaitable[tuple[str, str]]:
+    """
+    Look up the host name of an IP address.
+
+    :param sockaddr: socket address (e.g. (ipaddress, port) for IPv4)
+    :param flags: flags to pass to upstream ``getnameinfo()``
+    :return: a tuple of (host name, service name)
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. seealso:: :func:`socket.getnameinfo`
+
+    """
+    return get_async_backend().getnameinfo(sockaddr, flags)
+
+
+@deprecated("This function is deprecated; use `wait_readable` instead")
+def wait_socket_readable(sock: socket.socket) -> Awaitable[None]:
+    """
+    .. deprecated:: 4.7.0
+       Use :func:`wait_readable` instead.
+
+    Wait until the given socket has data to be read.
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher
+        level constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become readable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become readable
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().wait_readable(sock.fileno())
+
+
+@deprecated("This function is deprecated; use `wait_writable` instead")
+def wait_socket_writable(sock: socket.socket) -> Awaitable[None]:
+    """
+    .. deprecated:: 4.7.0
+       Use :func:`wait_writable` instead.
+
+    Wait until the given socket can be written to.
+
+    This does **NOT** work on Windows when using the asyncio backend with a proactor
+    event loop (default on py3.8+).
+
+    .. warning:: Only use this on raw sockets that have not been wrapped by any higher
+        level constructs like socket streams!
+
+    :param sock: a socket object
+    :raises ~anyio.ClosedResourceError: if the socket was closed while waiting for the
+        socket to become writable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the socket
+        to become writable
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().wait_writable(sock.fileno())
+
+
+def wait_readable(obj: FileDescriptorLike) -> Awaitable[None]:
+    """
+    Wait until the given object has data to be read.
+
+    On Unix systems, ``obj`` must either be an integer file descriptor, or else an
+    object with a ``.fileno()`` method which returns an integer file descriptor. Any
+    kind of file descriptor can be passed, though the exact semantics will depend on
+    your kernel. For example, this probably won't do anything useful for on-disk files.
+
+    On Windows systems, ``obj`` must either be an integer ``SOCKET`` handle, or else an
+    object with a ``.fileno()`` method which returns an integer ``SOCKET`` handle. File
+    descriptors aren't supported, and neither are handles that refer to anything besides
+    a ``SOCKET``.
+
+    On backends where this functionality is not natively provided (asyncio
+    ``ProactorEventLoop`` on Windows), it is provided using a separate selector thread
+    which is set to shut down when the interpreter shuts down.
+
+    .. warning:: Don't use this on raw sockets that have been wrapped by any higher
+        level constructs like socket streams!
+
+    :param obj: an object with a ``.fileno()`` method or an integer handle
+    :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the
+        object to become readable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the object
+        to become readable
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().wait_readable(obj)
+
+
+def wait_writable(obj: FileDescriptorLike) -> Awaitable[None]:
+    """
+    Wait until the given object can be written to.
+
+    :param obj: an object with a ``.fileno()`` method or an integer handle
+    :raises ~anyio.ClosedResourceError: if the object was closed while waiting for the
+        object to become writable
+    :raises ~anyio.BusyResourceError: if another task is already waiting for the object
+        to become writable
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. seealso:: See the documentation of :func:`wait_readable` for the definition of
+       ``obj`` and notes on backend compatibility.
+
+    .. warning:: Don't use this on raw sockets that have been wrapped by any higher
+        level constructs like socket streams!
+
+    """
+    return get_async_backend().wait_writable(obj)
+
+
+def notify_closing(obj: FileDescriptorLike) -> None:
+    """
+    Call this before closing a file descriptor (on Unix) or socket (on
+    Windows). This will cause any `wait_readable` or `wait_writable`
+    calls on the given object to immediately wake up and raise
+    `~anyio.ClosedResourceError`.
+
+    This doesn't actually close the object – you still have to do that
+    yourself afterwards. Also, you want to be careful to make sure no
+    new tasks start waiting on the object in between when you call this
+    and when it's actually closed. So to close something properly, you
+    usually want to do these steps in order:
+
+    1. Explicitly mark the object as closed, so that any new attempts
+       to use it will abort before they start.
+    2. Call `notify_closing` to wake up any already-existing users.
+    3. Actually close the object.
+
+    It's also possible to do them in a different order if that's more
+    convenient, *but only if* you make sure not to have any checkpoints in
+    between the steps. This way they all happen in a single atomic
+    step, so other tasks won't be able to tell what order they happened
+    in anyway.
+
+    :param obj: an object with a ``.fileno()`` method or an integer handle
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    get_async_backend().notify_closing(obj)
+
+
+#
+# Private API
+#
+
+
+def convert_ipv6_sockaddr(
+    sockaddr: tuple[str, int, int, int] | tuple[str, int],
+) -> tuple[str, int]:
+    """
+    Convert a 4-tuple IPv6 socket address to a 2-tuple (address, port) format.
+
+    If the scope ID is nonzero, it is added to the address, separated with ``%``.
+    Otherwise the flow id and scope id are simply cut off from the tuple.
+    Any other kinds of socket addresses are returned as-is.
+
+    :param sockaddr: the result of :meth:`~socket.socket.getsockname`
+    :return: the converted socket address
+
+    """
+    # This is more complicated than it should be because of MyPy
+    if isinstance(sockaddr, tuple) and len(sockaddr) == 4:
+        host, port, _flowinfo, scope_id = sockaddr
+        if scope_id:
+            # PyPy (as of v7.3.11) leaves the interface name in the result, so
+            # we discard it and only get the scope ID from the end
+            # (https://foss.heptapod.net/pypy/pypy/-/issues/3938)
+            host = host.split("%")[0]
+
+            # Add scope_id to the address
+            return f"{host}%{scope_id}", port
+        else:
+            return host, port
+    else:
+        return sockaddr
+
+
+async def setup_unix_local_socket(
+    path: None | str | bytes | PathLike[Any],
+    mode: int | None,
+    socktype: int,
+) -> socket.socket:
+    """
+    Create a UNIX local socket object, deleting the socket at the given path if it
+    exists.
+
+    Not available on Windows.
+
+    :param path: path of the socket
+    :param mode: permissions to set on the socket
+    :param socktype: socket.SOCK_STREAM or socket.SOCK_DGRAM
+
+    """
+    path_str: str | None
+    if path is not None:
+        path_str = os.fsdecode(path)
+
+        # Linux abstract namespace sockets aren't backed by a concrete file so skip stat call
+        if not path_str.startswith("\0"):
+            # Copied from pathlib...
+            try:
+                stat_result = os.stat(path)
+            except OSError as e:
+                if e.errno not in (
+                    errno.ENOENT,
+                    errno.ENOTDIR,
+                    errno.EBADF,
+                    errno.ELOOP,
+                ):
+                    raise
+            else:
+                if stat.S_ISSOCK(stat_result.st_mode):
+                    os.unlink(path)
+    else:
+        path_str = None
+
+    raw_socket = socket.socket(socket.AF_UNIX, socktype)
+    raw_socket.setblocking(False)
+
+    if path_str is not None:
+        try:
+            await to_thread.run_sync(raw_socket.bind, path_str, abandon_on_cancel=True)
+            if mode is not None:
+                await to_thread.run_sync(chmod, path_str, mode, abandon_on_cancel=True)
+        except BaseException:
+            raw_socket.close()
+            raise
+
+    return raw_socket
+
+
+@dataclass
+class TCPConnectable(ByteStreamConnectable):
+    """
+    Connects to a TCP server at the given host and port.
+
+    :param host: host name or IP address of the server
+    :param port: TCP port number of the server
+    """
+
+    host: str | IPv4Address | IPv6Address
+    port: int
+
+    def __post_init__(self) -> None:
+        if self.port < 1 or self.port > 65535:
+            raise ValueError("TCP port number out of range")
+
+    @override
+    async def connect(self) -> SocketStream:
+        try:
+            return await connect_tcp(self.host, self.port)
+        except OSError as exc:
+            raise ConnectionFailed(
+                f"error connecting to {self.host}:{self.port}: {exc}"
+            ) from exc
+
+
+@dataclass
+class UNIXConnectable(ByteStreamConnectable):
+    """
+    Connects to a UNIX domain socket at the given path.
+
+    :param path: the file system path of the socket
+    """
+
+    path: str | bytes | PathLike[str] | PathLike[bytes]
+
+    @override
+    async def connect(self) -> UNIXSocketStream:
+        try:
+            return await connect_unix(self.path)
+        except OSError as exc:
+            raise ConnectionFailed(f"error connecting to {self.path!r}: {exc}") from exc
+
+
+def as_connectable(
+    remote: ByteStreamConnectable
+    | tuple[str | IPv4Address | IPv6Address, int]
+    | str
+    | bytes
+    | PathLike[str],
+    /,
+    *,
+    tls: bool = False,
+    ssl_context: ssl.SSLContext | None = None,
+    tls_hostname: str | None = None,
+    tls_standard_compatible: bool = True,
+) -> ByteStreamConnectable:
+    """
+    Return a byte stream connectable from the given object.
+
+    If a bytestream connectable is given, it is returned unchanged.
+    If a tuple of (host, port) is given, a TCP connectable is returned.
+    If a string or bytes path is given, a UNIX connectable is returned.
+
+    If ``tls=True``, the connectable will be wrapped in a
+    :class:`~.streams.tls.TLSConnectable`.
+
+    :param remote: a connectable, a tuple of (host, port) or a path to a UNIX socket
+    :param tls: if ``True``, wrap the plaintext connectable in a
+        :class:`~.streams.tls.TLSConnectable`, using the provided TLS settings)
+    :param ssl_context: if ``tls=True``, the SSLContext object to use  (if not provided,
+        a secure default will be created)
+    :param tls_hostname: if ``tls=True``, host name of the server to use for checking
+        the server certificate (defaults to the host portion of the address for TCP
+        connectables)
+    :param tls_standard_compatible: if ``False`` and ``tls=True``, makes the TLS stream
+        skip the closing handshake when closing the connection, so it won't raise an
+        exception if the server does the same
+
+    """
+    connectable: TCPConnectable | UNIXConnectable | TLSConnectable
+    if isinstance(remote, ByteStreamConnectable):
+        return remote
+    elif isinstance(remote, tuple) and len(remote) == 2:
+        connectable = TCPConnectable(*remote)
+    elif isinstance(remote, (str, bytes, PathLike)):
+        connectable = UNIXConnectable(remote)
+    else:
+        raise TypeError(f"cannot convert {remote!r} to a connectable")
+
+    if tls:
+        if not tls_hostname and isinstance(connectable, TCPConnectable):
+            tls_hostname = str(connectable.host)
+
+        connectable = TLSConnectable(
+            connectable,
+            ssl_context=ssl_context,
+            hostname=tls_hostname,
+            standard_compatible=tls_standard_compatible,
+        )
+
+    return connectable
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_streams.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_streams.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b9c7df200f9520357503c754bcdea1c047bdda3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_streams.py
@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import math
+from typing import TypeVar
+from warnings import warn
+
+from ..streams.memory import (
+    MemoryObjectReceiveStream,
+    MemoryObjectSendStream,
+    _MemoryObjectStreamState,
+)
+
+T_Item = TypeVar("T_Item")
+
+
+class create_memory_object_stream(
+    tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]],
+):
+    """
+    Create a memory object stream.
+
+    The stream's item type can be annotated like
+    :func:`create_memory_object_stream[T_Item]`.
+
+    :param max_buffer_size: number of items held in the buffer until ``send()`` starts
+        blocking
+    :param item_type: old way of marking the streams with the right generic type for
+        static typing (does nothing on AnyIO 4)
+
+        .. deprecated:: 4.0
+          Use ``create_memory_object_stream[YourItemType](...)`` instead.
+    :return: a tuple of (send stream, receive stream)
+
+    """
+
+    def __new__(  # type: ignore[misc]
+        cls, max_buffer_size: float = 0, item_type: object = None
+    ) -> tuple[MemoryObjectSendStream[T_Item], MemoryObjectReceiveStream[T_Item]]:
+        if max_buffer_size != math.inf and not isinstance(max_buffer_size, int):
+            raise ValueError("max_buffer_size must be either an integer or math.inf")
+        if max_buffer_size < 0:
+            raise ValueError("max_buffer_size cannot be negative")
+        if item_type is not None:
+            warn(
+                "The item_type argument has been deprecated in AnyIO 4.0. "
+                "Use create_memory_object_stream[YourItemType](...) instead.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+
+        state = _MemoryObjectStreamState[T_Item](max_buffer_size)
+        return (MemoryObjectSendStream(state), MemoryObjectReceiveStream(state))
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_subprocesses.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_subprocesses.py
new file mode 100644
index 0000000000000000000000000000000000000000..53184a2e6cd238fcc56e9eb5b3374b25eeaf7741
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_subprocesses.py
@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+from collections.abc import AsyncIterable, Iterable, Mapping, Sequence
+from io import BytesIO
+from os import PathLike
+from subprocess import PIPE, CalledProcessError, CompletedProcess
+from typing import IO, Any, TypeAlias, cast
+
+from ..abc import Process  # noqa: TC001
+from ._eventloop import get_async_backend
+from ._tasks import create_task_group
+
+StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
+
+
+async def run_process(
+    command: StrOrBytesPath | Sequence[StrOrBytesPath],
+    *,
+    input: bytes | None = None,
+    stdin: int | IO[Any] | None = None,
+    stdout: int | IO[Any] | None = PIPE,
+    stderr: int | IO[Any] | None = PIPE,
+    check: bool = True,
+    cwd: StrOrBytesPath | None = None,
+    env: Mapping[str, str] | None = None,
+    startupinfo: Any = None,
+    creationflags: int = 0,
+    start_new_session: bool = False,
+    pass_fds: Sequence[int] = (),
+    user: str | int | None = None,
+    group: str | int | None = None,
+    extra_groups: Iterable[str | int] | None = None,
+    umask: int = -1,
+) -> CompletedProcess[bytes]:
+    """
+    Run an external command in a subprocess and wait until it completes.
+
+    .. seealso:: :func:`subprocess.run`
+
+    :param command: either a string to pass to the shell, or an iterable of strings
+        containing the executable name or path and its arguments
+    :param input: bytes passed to the standard input of the subprocess
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or `None`; ``input`` overrides this
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or `None`
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or `None`
+    :param check: if ``True``, raise :exc:`~subprocess.CalledProcessError` if the
+        process terminates with a return code other than 0
+    :param cwd: If not ``None``, change the working directory to this before running the
+        command
+    :param env: if not ``None``, this mapping replaces the inherited environment
+        variables from the parent process
+    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
+        to specify process startup parameters (Windows only)
+    :param creationflags: flags that can be used to control the creation of the
+        subprocess (see :class:`subprocess.Popen` for the specifics)
+    :param start_new_session: if ``true`` the setsid() system call will be made in the
+        child process prior to the execution of the subprocess. (POSIX only)
+    :param pass_fds: sequence of file descriptors to keep open between the parent and
+        child processes. (POSIX only)
+    :param user: effective user to run the process as (Python >= 3.9, POSIX only)
+    :param group: effective group to run the process as (Python >= 3.9, POSIX only)
+    :param extra_groups: supplementary groups to set in the subprocess (Python >= 3.9,
+        POSIX only)
+    :param umask: if not negative, this umask is applied in the child process before
+        running the given command (Python >= 3.9, POSIX only)
+    :return: an object representing the completed process
+    :raises ~subprocess.CalledProcessError: if ``check`` is ``True`` and the process
+        exits with a nonzero return code
+
+    """
+
+    async def drain_stream(stream: AsyncIterable[bytes], index: int) -> None:
+        buffer = BytesIO()
+        async for chunk in stream:
+            buffer.write(chunk)
+
+        stream_contents[index] = buffer.getvalue()
+
+    if stdin is not None and input is not None:
+        raise ValueError("only one of stdin and input is allowed")
+
+    async with await open_process(
+        command,
+        stdin=PIPE if input else stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        startupinfo=startupinfo,
+        creationflags=creationflags,
+        start_new_session=start_new_session,
+        pass_fds=pass_fds,
+        user=user,
+        group=group,
+        extra_groups=extra_groups,
+        umask=umask,
+    ) as process:
+        stream_contents: list[bytes | None] = [None, None]
+        async with create_task_group() as tg:
+            if process.stdout:
+                tg.start_soon(drain_stream, process.stdout, 0)
+
+            if process.stderr:
+                tg.start_soon(drain_stream, process.stderr, 1)
+
+            if process.stdin and input:
+                await process.stdin.send(input)
+                await process.stdin.aclose()
+
+            await process.wait()
+
+    output, errors = stream_contents
+    if check and process.returncode != 0:
+        raise CalledProcessError(cast(int, process.returncode), command, output, errors)
+
+    return CompletedProcess(command, cast(int, process.returncode), output, errors)
+
+
+async def open_process(
+    command: StrOrBytesPath | Sequence[StrOrBytesPath],
+    *,
+    stdin: int | IO[Any] | None = PIPE,
+    stdout: int | IO[Any] | None = PIPE,
+    stderr: int | IO[Any] | None = PIPE,
+    cwd: StrOrBytesPath | None = None,
+    env: Mapping[str, str] | None = None,
+    startupinfo: Any = None,
+    creationflags: int = 0,
+    start_new_session: bool = False,
+    pass_fds: Sequence[int] = (),
+    user: str | int | None = None,
+    group: str | int | None = None,
+    extra_groups: Iterable[str | int] | None = None,
+    umask: int = -1,
+) -> Process:
+    """
+    Start an external command in a subprocess.
+
+    .. seealso:: :class:`subprocess.Popen`
+
+    :param command: either a string to pass to the shell, or an iterable of strings
+        containing the executable name or path and its arguments
+    :param stdin: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`, a
+        file-like object, or ``None``
+    :param stdout: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        a file-like object, or ``None``
+    :param stderr: one of :data:`subprocess.PIPE`, :data:`subprocess.DEVNULL`,
+        :data:`subprocess.STDOUT`, a file-like object, or ``None``
+    :param cwd: If not ``None``, the working directory is changed before executing
+    :param env: If env is not ``None``, it must be a mapping that defines the
+        environment variables for the new process
+    :param creationflags: flags that can be used to control the creation of the
+        subprocess (see :class:`subprocess.Popen` for the specifics)
+    :param startupinfo: an instance of :class:`subprocess.STARTUPINFO` that can be used
+        to specify process startup parameters (Windows only)
+    :param start_new_session: if ``true`` the setsid() system call will be made in the
+        child process prior to the execution of the subprocess. (POSIX only)
+    :param pass_fds: sequence of file descriptors to keep open between the parent and
+        child processes. (POSIX only)
+    :param user: effective user to run the process as (POSIX only)
+    :param group: effective group to run the process as (POSIX only)
+    :param extra_groups: supplementary groups to set in the subprocess (POSIX only)
+    :param umask: if not negative, this umask is applied in the child process before
+        running the given command (POSIX only)
+    :return: an asynchronous process object
+
+    """
+    kwargs: dict[str, Any] = {}
+    if user is not None:
+        kwargs["user"] = user
+
+    if group is not None:
+        kwargs["group"] = group
+
+    if extra_groups is not None:
+        kwargs["extra_groups"] = extra_groups
+
+    if umask >= 0:
+        kwargs["umask"] = umask
+
+    return await get_async_backend().open_process(
+        command,
+        stdin=stdin,
+        stdout=stdout,
+        stderr=stderr,
+        cwd=cwd,
+        env=env,
+        startupinfo=startupinfo,
+        creationflags=creationflags,
+        start_new_session=start_new_session,
+        pass_fds=pass_fds,
+        **kwargs,
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_synchronization.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_synchronization.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb988c60db56f412ae0e051e08d68380e8b6a413
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_synchronization.py
@@ -0,0 +1,778 @@
+from __future__ import annotations
+
+import math
+import sys
+from collections import deque
+from collections.abc import Callable
+from dataclasses import dataclass
+from types import TracebackType
+from typing import TypeVar
+
+from ..lowlevel import checkpoint_if_cancelled
+from ._eventloop import get_async_backend
+from ._exceptions import BusyResourceError, NoEventLoopError
+from ._tasks import CancelScope
+from ._testing import TaskInfo, get_current_task
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class EventStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Event.wait`
+    """
+
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class CapacityLimiterStatistics:
+    """
+    :ivar int borrowed_tokens: number of tokens currently borrowed by tasks
+    :ivar float total_tokens: total number of available tokens
+    :ivar tuple borrowers: tasks or other objects currently holding tokens borrowed from
+        this limiter
+    :ivar int tasks_waiting: number of tasks waiting on
+        :meth:`~.CapacityLimiter.acquire` or
+        :meth:`~.CapacityLimiter.acquire_on_behalf_of`
+    """
+
+    borrowed_tokens: int
+    total_tokens: float
+    borrowers: tuple[object, ...]
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class LockStatistics:
+    """
+    :ivar bool locked: flag indicating if this lock is locked or not
+    :ivar ~anyio.TaskInfo owner: task currently holding the lock (or ``None`` if the
+        lock is not held by any task)
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Lock.acquire`
+    """
+
+    locked: bool
+    owner: TaskInfo | None
+    tasks_waiting: int
+
+
+@dataclass(frozen=True)
+class ConditionStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks blocked on :meth:`~.Condition.wait`
+    :ivar ~anyio.LockStatistics lock_statistics: statistics of the underlying
+        :class:`~.Lock`
+    """
+
+    tasks_waiting: int
+    lock_statistics: LockStatistics
+
+
+@dataclass(frozen=True)
+class SemaphoreStatistics:
+    """
+    :ivar int tasks_waiting: number of tasks waiting on :meth:`~.Semaphore.acquire`
+
+    """
+
+    tasks_waiting: int
+
+
+class Event:
+    __slots__ = ("__weakref__",)
+
+    def __new__(cls) -> Event:
+        try:
+            return get_async_backend().create_event()
+        except NoEventLoopError:
+            return EventAdapter()
+
+    def set(self) -> None:
+        """Set the flag, notifying all listeners."""
+        raise NotImplementedError
+
+    def is_set(self) -> bool:
+        """Return ``True`` if the flag is set, ``False`` if not."""
+        raise NotImplementedError
+
+    async def wait(self) -> None:
+        """
+        Wait until the flag has been set.
+
+        If the flag has already been set when this method is called, it returns
+        immediately.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> EventStatistics:
+        """Return statistics about the current state of this event."""
+        raise NotImplementedError
+
+
+class EventAdapter(Event):
+    __slots__ = "_internal_event", "_is_set"
+
+    def __new__(cls) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self) -> None:
+        self._internal_event: Event | None = None
+        self._is_set = False
+
+    @property
+    def _event(self) -> Event:
+        if self._internal_event is None:
+            self._internal_event = get_async_backend().create_event()
+            if self._is_set:
+                self._internal_event.set()
+
+        return self._internal_event
+
+    def set(self) -> None:
+        if self._internal_event is None:
+            self._is_set = True
+        else:
+            self._event.set()
+
+    def is_set(self) -> bool:
+        if self._internal_event is None:
+            return self._is_set
+
+        return self._internal_event.is_set()
+
+    async def wait(self) -> None:
+        await self._event.wait()
+
+    def statistics(self) -> EventStatistics:
+        if self._internal_event is None:
+            return EventStatistics(tasks_waiting=0)
+
+        return self._internal_event.statistics()
+
+
+class Lock:
+    __slots__ = ("__weakref__",)
+
+    def __new__(cls, *, fast_acquire: bool = False) -> Lock:
+        try:
+            return get_async_backend().create_lock(fast_acquire=fast_acquire)
+        except NoEventLoopError:
+            return LockAdapter(fast_acquire=fast_acquire)
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Acquire the lock."""
+        raise NotImplementedError
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the lock, without blocking.
+
+        :raises ~anyio.WouldBlock: if the operation would block
+
+        """
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """Release the lock."""
+        raise NotImplementedError
+
+    def locked(self) -> bool:
+        """Return True if the lock is currently held."""
+        raise NotImplementedError
+
+    def statistics(self) -> LockStatistics:
+        """
+        Return statistics about the current state of this lock.
+
+        .. versionadded:: 3.0
+        """
+        raise NotImplementedError
+
+
+class LockAdapter(Lock):
+    __slots__ = "_fast_acquire", "_internal_lock"
+
+    def __new__(cls, *, fast_acquire: bool = False) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, *, fast_acquire: bool = False):
+        self._internal_lock: Lock | None = None
+        self._fast_acquire = fast_acquire
+
+    @property
+    def _lock(self) -> Lock:
+        if self._internal_lock is None:
+            self._internal_lock = get_async_backend().create_lock(
+                fast_acquire=self._fast_acquire
+            )
+
+        return self._internal_lock
+
+    async def __aenter__(self) -> None:
+        await self._lock.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        if self._internal_lock is not None:
+            self._internal_lock.release()
+
+    async def acquire(self) -> None:
+        """Acquire the lock."""
+        await self._lock.acquire()
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the lock, without blocking.
+
+        :raises ~anyio.WouldBlock: if the operation would block
+
+        """
+        self._lock.acquire_nowait()
+
+    def release(self) -> None:
+        """Release the lock."""
+        self._lock.release()
+
+    def locked(self) -> bool:
+        """Return True if the lock is currently held."""
+        return self._lock.locked()
+
+    def statistics(self) -> LockStatistics:
+        """
+        Return statistics about the current state of this lock.
+
+        .. versionadded:: 3.0
+
+        """
+        if self._internal_lock is None:
+            return LockStatistics(False, None, 0)
+
+        return self._internal_lock.statistics()
+
+
+class Condition:
+    __slots__ = "__weakref__", "_lock", "_owner_task", "_waiters"
+
+    def __init__(self, lock: Lock | None = None):
+        self._owner_task: TaskInfo | None = None
+        self._lock = lock or Lock()
+        self._waiters: deque[Event] = deque()
+
+    async def __aenter__(self) -> None:
+        await self.acquire()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.release()
+
+    def _check_acquired(self) -> None:
+        if self._owner_task != get_current_task():
+            raise RuntimeError("The current task is not holding the underlying lock")
+
+    async def acquire(self) -> None:
+        """Acquire the underlying lock."""
+        await self._lock.acquire()
+        self._owner_task = get_current_task()
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~anyio.WouldBlock: if the operation would block
+
+        """
+        self._lock.acquire_nowait()
+        self._owner_task = get_current_task()
+
+    def release(self) -> None:
+        """Release the underlying lock."""
+        self._lock.release()
+
+    def locked(self) -> bool:
+        """Return True if the lock is set."""
+        return self._lock.locked()
+
+    def notify(self, n: int = 1) -> None:
+        """Notify exactly n listeners."""
+        self._check_acquired()
+        for _ in range(n):
+            try:
+                event = self._waiters.popleft()
+            except IndexError:
+                break
+
+            event.set()
+
+    def notify_all(self) -> None:
+        """Notify all the listeners."""
+        self._check_acquired()
+        for event in self._waiters:
+            event.set()
+
+        self._waiters.clear()
+
+    async def wait(self) -> None:
+        """Wait for a notification."""
+        await checkpoint_if_cancelled()
+        self._check_acquired()
+        event = Event()
+        self._waiters.append(event)
+        self.release()
+        try:
+            await event.wait()
+        except BaseException:
+            if not event.is_set():
+                self._waiters.remove(event)
+            elif self._waiters:
+                # This task was notified by could not act on it, so pass
+                # it on to the next task
+                self._waiters.popleft().set()
+
+            raise
+        finally:
+            with CancelScope(shield=True):
+                await self.acquire()
+
+    async def wait_for(self, predicate: Callable[[], T]) -> T:
+        """
+        Wait until a predicate becomes true.
+
+        :param predicate: a callable that returns a truthy value when the condition is
+            met
+        :return: the result of the predicate
+
+        .. versionadded:: 4.11.0
+
+        """
+        while not (result := predicate()):
+            await self.wait()
+
+        return result
+
+    def statistics(self) -> ConditionStatistics:
+        """
+        Return statistics about the current state of this condition.
+
+        .. versionadded:: 3.0
+        """
+        return ConditionStatistics(len(self._waiters), self._lock.statistics())
+
+
+class Semaphore:
+    __slots__ = "__weakref__", "_fast_acquire"
+
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        try:
+            return get_async_backend().create_semaphore(
+                initial_value, max_value=max_value, fast_acquire=fast_acquire
+            )
+        except NoEventLoopError:
+            return SemaphoreAdapter(initial_value, max_value=max_value)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ):
+        if not isinstance(initial_value, int):
+            raise TypeError("initial_value must be an integer")
+        if initial_value < 0:
+            raise ValueError("initial_value must be >= 0")
+        if max_value is not None:
+            if not isinstance(max_value, int):
+                raise TypeError("max_value must be an integer or None")
+            if max_value < initial_value:
+                raise ValueError(
+                    "max_value must be equal to or higher than initial_value"
+                )
+
+        self._fast_acquire = fast_acquire
+
+    async def __aenter__(self) -> Self:
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.release()
+
+    async def acquire(self) -> None:
+        """Decrement the semaphore value, blocking if necessary."""
+        raise NotImplementedError
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire the underlying lock, without blocking.
+
+        :raises ~anyio.WouldBlock: if the operation would block
+
+        """
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """Increment the semaphore value."""
+        raise NotImplementedError
+
+    @property
+    def value(self) -> int:
+        """The current value of the semaphore."""
+        raise NotImplementedError
+
+    @property
+    def max_value(self) -> int | None:
+        """The maximum value of the semaphore."""
+        raise NotImplementedError
+
+    def statistics(self) -> SemaphoreStatistics:
+        """
+        Return statistics about the current state of this semaphore.
+
+        .. versionadded:: 3.0
+        """
+        raise NotImplementedError
+
+
+class SemaphoreAdapter(Semaphore):
+    __slots__ = "_initial_value", "_internal_semaphore", "_max_value"
+
+    def __new__(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Self:
+        return object.__new__(cls)
+
+    def __init__(
+        self,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> None:
+        super().__init__(initial_value, max_value=max_value, fast_acquire=fast_acquire)
+        self._internal_semaphore: Semaphore | None = None
+        self._initial_value = initial_value
+        self._max_value = max_value
+
+    @property
+    def _semaphore(self) -> Semaphore:
+        if self._internal_semaphore is None:
+            self._internal_semaphore = get_async_backend().create_semaphore(
+                self._initial_value, max_value=self._max_value
+            )
+
+        return self._internal_semaphore
+
+    async def acquire(self) -> None:
+        await self._semaphore.acquire()
+
+    def acquire_nowait(self) -> None:
+        self._semaphore.acquire_nowait()
+
+    def release(self) -> None:
+        self._semaphore.release()
+
+    @property
+    def value(self) -> int:
+        if self._internal_semaphore is None:
+            return self._initial_value
+
+        return self._semaphore.value
+
+    @property
+    def max_value(self) -> int | None:
+        return self._max_value
+
+    def statistics(self) -> SemaphoreStatistics:
+        if self._internal_semaphore is None:
+            return SemaphoreStatistics(tasks_waiting=0)
+
+        return self._semaphore.statistics()
+
+
+class CapacityLimiter:
+    __slots__ = ("__weakref__",)
+
+    def __new__(cls, total_tokens: float) -> CapacityLimiter:
+        try:
+            return get_async_backend().create_capacity_limiter(total_tokens)
+        except NoEventLoopError:
+            return CapacityLimiterAdapter(total_tokens)
+
+    async def __aenter__(self) -> None:
+        raise NotImplementedError
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        raise NotImplementedError
+
+    @property
+    def total_tokens(self) -> float:
+        """
+        The total number of tokens available for borrowing.
+
+        This is a read-write property. If the total number of tokens is increased, the
+        proportionate number of tasks waiting on this limiter will be granted their
+        tokens.
+
+        .. versionchanged:: 3.0
+            The property is now writable.
+        .. versionchanged:: 4.12
+            The value can now be set to 0.
+
+        """
+        raise NotImplementedError
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        raise NotImplementedError
+
+    @property
+    def borrowed_tokens(self) -> int:
+        """The number of tokens that have currently been borrowed."""
+        raise NotImplementedError
+
+    @property
+    def available_tokens(self) -> float:
+        """The number of tokens currently available to be borrowed"""
+        raise NotImplementedError
+
+    def acquire_nowait(self) -> None:
+        """
+        Acquire a token for the current task without waiting for one to become
+        available.
+
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        """
+        Acquire a token without waiting for one to become available.
+
+        :param borrower: the entity borrowing a token
+        :raises ~anyio.WouldBlock: if there are no tokens available for borrowing
+
+        """
+        raise NotImplementedError
+
+    async def acquire(self) -> None:
+        """
+        Acquire a token for the current task, waiting if necessary for one to become
+        available.
+
+        """
+        raise NotImplementedError
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        """
+        Acquire a token, waiting if necessary for one to become available.
+
+        :param borrower: the entity borrowing a token
+
+        """
+        raise NotImplementedError
+
+    def release(self) -> None:
+        """
+        Release the token held by the current task.
+
+        :raises RuntimeError: if the current task has not borrowed a token from this
+            limiter.
+
+        """
+        raise NotImplementedError
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        """
+        Release the token held by the given borrower.
+
+        :raises RuntimeError: if the borrower has not borrowed a token from this
+            limiter.
+
+        """
+        raise NotImplementedError
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        """
+        Return statistics about the current state of this limiter.
+
+        .. versionadded:: 3.0
+
+        """
+        raise NotImplementedError
+
+
+class CapacityLimiterAdapter(CapacityLimiter):
+    __slots__ = "_internal_limiter", "_total_tokens"
+
+    def __new__(cls, total_tokens: float) -> Self:
+        return object.__new__(cls)
+
+    def __init__(self, total_tokens: float) -> None:
+        self._internal_limiter: CapacityLimiter | None = None
+        self.total_tokens = total_tokens
+
+    @property
+    def _limiter(self) -> CapacityLimiter:
+        if self._internal_limiter is None:
+            self._internal_limiter = get_async_backend().create_capacity_limiter(
+                self._total_tokens
+            )
+
+        return self._internal_limiter
+
+    async def __aenter__(self) -> None:
+        await self._limiter.__aenter__()
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        return await self._limiter.__aexit__(exc_type, exc_val, exc_tb)
+
+    @property
+    def total_tokens(self) -> float:
+        if self._internal_limiter is None:
+            return self._total_tokens
+
+        return self._internal_limiter.total_tokens
+
+    @total_tokens.setter
+    def total_tokens(self, value: float) -> None:
+        if not isinstance(value, int) and not math.isinf(value):
+            raise TypeError("total_tokens must be an int or math.inf")
+        elif value < 0:
+            raise ValueError("total_tokens must be >= 0")
+
+        if self._internal_limiter is None:
+            self._total_tokens = value
+            return
+
+        self._limiter.total_tokens = value
+
+    @property
+    def borrowed_tokens(self) -> int:
+        if self._internal_limiter is None:
+            return 0
+
+        return self._internal_limiter.borrowed_tokens
+
+    @property
+    def available_tokens(self) -> float:
+        if self._internal_limiter is None:
+            return self._total_tokens
+
+        return self._internal_limiter.available_tokens
+
+    def acquire_nowait(self) -> None:
+        self._limiter.acquire_nowait()
+
+    def acquire_on_behalf_of_nowait(self, borrower: object) -> None:
+        self._limiter.acquire_on_behalf_of_nowait(borrower)
+
+    async def acquire(self) -> None:
+        await self._limiter.acquire()
+
+    async def acquire_on_behalf_of(self, borrower: object) -> None:
+        await self._limiter.acquire_on_behalf_of(borrower)
+
+    def release(self) -> None:
+        self._limiter.release()
+
+    def release_on_behalf_of(self, borrower: object) -> None:
+        self._limiter.release_on_behalf_of(borrower)
+
+    def statistics(self) -> CapacityLimiterStatistics:
+        if self._internal_limiter is None:
+            return CapacityLimiterStatistics(
+                borrowed_tokens=0,
+                total_tokens=self.total_tokens,
+                borrowers=(),
+                tasks_waiting=0,
+            )
+
+        return self._internal_limiter.statistics()
+
+
+class ResourceGuard:
+    """
+    A context manager for ensuring that a resource is only used by a single task at a
+    time.
+
+    Entering this context manager while the previous has not exited it yet will trigger
+    :exc:`BusyResourceError`.
+
+    :param action: the action to guard against (visible in the :exc:`BusyResourceError`
+        when triggered, e.g. "Another task is already {action} this resource")
+
+    .. versionadded:: 4.1
+    """
+
+    __slots__ = "__weakref__", "_guarded", "action"
+
+    def __init__(self, action: str = "using"):
+        self.action: str = action
+        self._guarded = False
+
+    def __enter__(self) -> None:
+        if self._guarded:
+            raise BusyResourceError(self.action)
+
+        self._guarded = True
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._guarded = False
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tasks.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tasks.py
new file mode 100644
index 0000000000000000000000000000000000000000..044eda6dc90ab446b5b6e1dc1626cb6dd510e7db
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tasks.py
@@ -0,0 +1,464 @@
+from __future__ import annotations
+
+import math
+import sys
+from collections.abc import (
+    Coroutine,
+    Generator,
+)
+from contextlib import contextmanager
+from enum import Enum, auto
+from inspect import iscoroutine
+from types import TracebackType
+from typing import Any, Generic, final
+
+from ..abc import TaskGroup, TaskStatus
+from ._eventloop import get_async_backend, get_cancelled_exc_class
+from ._exceptions import TaskCancelled, TaskFailed, TaskNotFinished
+
+if sys.version_info >= (3, 13):
+    from typing import TypeVar
+else:
+    from typing_extensions import TypeVar
+
+if sys.version_info >= (3, 11):
+    from typing import Never, Self, TypeVarTuple
+else:
+    from typing_extensions import Never, Self, TypeVarTuple
+
+T = TypeVar("T")
+T_co = TypeVar("T_co", covariant=True)
+T_startval_co = TypeVar("T_startval_co", covariant=True, default=Never)
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+class _IgnoredTaskStatus(TaskStatus[object]):
+    def started(self, value: object = None) -> None:
+        pass
+
+
+TASK_STATUS_IGNORED = _IgnoredTaskStatus()
+
+
+class CancelScope:
+    """
+    Wraps a unit of work that can be made separately cancellable.
+
+    :param deadline: The time (clock value) when this scope is cancelled automatically
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+    """
+
+    __slots__ = ("__weakref__",)
+
+    def __new__(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> CancelScope:
+        return get_async_backend().create_cancel_scope(shield=shield, deadline=deadline)
+
+    def cancel(self, reason: str | None = None) -> None:
+        """
+        Cancel this scope immediately.
+
+        :param reason: a message describing the reason for the cancellation
+
+        """
+        raise NotImplementedError
+
+    @property
+    def deadline(self) -> float:
+        """
+        The time (clock value) when this scope is cancelled automatically.
+
+        Will be ``float('inf')`` if no timeout has been set.
+
+        """
+        raise NotImplementedError
+
+    @deadline.setter
+    def deadline(self, value: float) -> None:
+        raise NotImplementedError
+
+    @property
+    def cancel_called(self) -> bool:
+        """``True`` if :meth:`cancel` has been called."""
+        raise NotImplementedError
+
+    @property
+    def cancelled_caught(self) -> bool:
+        """
+        ``True`` if this scope suppressed a cancellation exception it itself raised.
+
+        This is typically used to check if any work was interrupted, or to see if the
+        scope was cancelled due to its deadline being reached. The value will, however,
+        only be ``True`` if the cancellation was triggered by the scope itself (and not
+        an outer scope).
+
+        """
+        raise NotImplementedError
+
+    @property
+    def shield(self) -> bool:
+        """
+        ``True`` if this scope is shielded from external cancellation.
+
+        While a scope is shielded, it will not receive cancellations from outside.
+
+        """
+        raise NotImplementedError
+
+    @shield.setter
+    def shield(self, value: bool) -> None:
+        raise NotImplementedError
+
+    def __enter__(self) -> Self:
+        raise NotImplementedError
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        raise NotImplementedError
+
+
+@contextmanager
+def fail_at(
+    deadline: float | None, shield: bool = False, reason: str | None = None
+) -> Generator[CancelScope, None, None]:
+    """
+    Create a context manager which raises a :class:`TimeoutError` if the code in the
+    enclosing context does not finish by the given deadline.
+
+    :param deadline: the deadline before raising the exception, or
+        ``None`` to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :param reason: explanation for timeout to add to the message of a raised `TimeoutError`
+    :return: a context manager that yields a cancel scope
+    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\]
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. versionadded:: 4.15.0
+
+    """
+    current_time = get_async_backend().current_time
+    effective_deadline = math.inf if deadline is None else deadline
+    with get_async_backend().create_cancel_scope(
+        deadline=effective_deadline, shield=shield
+    ) as cancel_scope:
+        yield cancel_scope
+
+    if cancel_scope.cancelled_caught and current_time() >= cancel_scope.deadline:
+        raise TimeoutError(reason) if reason else TimeoutError
+
+
+@contextmanager
+def fail_after(
+    delay: float | None, shield: bool = False, reason: str | None = None
+) -> Generator[CancelScope, None, None]:
+    """
+    Create a context manager which raises a :class:`TimeoutError` if the code in the
+    enclosing context block does not finish in time.
+
+    :param delay: maximum allowed time (in seconds) before raising the exception, or
+        ``None`` to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :param reason: explanation for timeout to add to the message of a raised `TimeoutError`
+    :return: a context manager that yields a cancel scope
+    :rtype: :class:`~typing.ContextManager`\\[:class:`~anyio.CancelScope`\\]
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    current_time = get_async_backend().current_time
+    deadline = (current_time() + delay) if delay is not None else math.inf
+    with fail_at(deadline, shield=shield, reason=reason) as scope:
+        yield scope
+
+
+def move_on_at(deadline: float | None, shield: bool = False) -> CancelScope:
+    """
+    Create a cancel scope with a deadline that expires after the given delay.
+
+    :param deadline: the deadline before exiting the context block, or
+        ``None`` to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. versionadded:: 4.15.0
+
+    """
+    return get_async_backend().create_cancel_scope(
+        deadline=deadline if deadline is not None else math.inf, shield=shield
+    )
+
+
+def move_on_after(delay: float | None, shield: bool = False) -> CancelScope:
+    """
+    Create a cancel scope with a deadline that expires after the given delay.
+
+    :param delay: maximum allowed time (in seconds) before exiting the context block, or
+        ``None`` to disable the timeout
+    :param shield: ``True`` to shield the cancel scope from external cancellation
+    :return: a cancel scope
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. note:: Unlike with :func:`fail_after`, the timer starts when this function is
+        called, not when the context manager is entered. This will be changed in v5.0.
+
+    """
+    deadline = (
+        (get_async_backend().current_time() + delay) if delay is not None else math.inf
+    )
+    return get_async_backend().create_cancel_scope(deadline=deadline, shield=shield)
+
+
+def current_effective_deadline() -> float:
+    """
+    Return the nearest deadline among all the cancel scopes effective for the current
+    task.
+
+    :return: a clock value from the event loop's internal clock (or ``float('inf')`` if
+        there is no deadline in effect, or ``float('-inf')`` if the current scope has
+        been cancelled)
+    :rtype: float
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().current_effective_deadline()
+
+
+def create_task_group() -> TaskGroup:
+    """
+    Create a task group.
+
+    :return: a task group
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().create_task_group()
+
+
+@final
+class TaskHandle(Generic[T_co, T_startval_co]):
+    """
+    Returned from the task-spawning methods of :class:`TaskGroup`. Can be awaited on to
+    get the return value of the task (or the raised exception). If the task was
+    terminated by a :exc:`BaseException`, :exc:`TaskFailed` will be raised (or its
+    subclass :exc:`TaskCancelled` if the task was cancelled).
+
+    .. versionadded:: 4.14.0
+    """
+
+    class Status(Enum):
+        """
+        The status of a task handle.
+
+        .. attribute:: PENDING
+
+            The task has not finished yet.
+        .. attribute:: FINISHED
+
+            The task has finished with a return value.
+        .. attribute:: CANCELLING
+
+            The task has been cancelled but has not finished yet.
+        .. attribute:: CANCELLED
+
+            The task was cancelled and has finished since.
+        .. attribute:: FAILED
+
+            The task raised an exception.
+        """
+
+        PENDING = auto()
+        FINISHED = auto()
+        CANCELLING = auto()
+        CANCELLED = auto()
+        FAILED = auto()
+
+    __slots__ = (
+        "__weakref__",
+        "_cancel_scope",
+        "_coro",
+        "_exception",
+        "_finished_event",
+        "_name",
+        "_return_value",
+        "_start_value",
+    )
+
+    _return_value: T_co
+    _start_value: T_startval_co
+
+    def __init__(
+        self,
+        coro: Coroutine[Any, Any, T_co],
+        name: object,
+        cancel_scope: CancelScope | None = None,
+    ) -> None:
+        from ._synchronization import Event
+
+        self._coro = coro
+        self._cancel_scope = cancel_scope if cancel_scope is not None else CancelScope()
+        self._finished_event = Event()
+        self._exception: BaseException | None = None
+
+        if name is not None:
+            self._name = str(name)
+        elif iscoroutine(coro):
+            self._name = coro.__qualname__
+        else:
+            self._name = str(coro)  # coroutine-like object (e.g. asend() objects)
+
+    async def _run_coro(self) -> None:
+        __tracebackhide__ = True
+
+        with self._cancel_scope:
+            try:
+                retval = await self._coro
+            except BaseException as exc:
+                self._exception = exc
+                raise
+            else:
+                self._return_value = retval
+            finally:
+                self._finished_event.set()
+                del self  # Break the reference cycle
+
+    def cancel(self) -> None:
+        """
+        Set the task to a cancelled state.
+
+        This will interrupt any interruptible asynchronous operation, and will cause
+        any further awaits on this task to get immediately cancelled, unless done in
+        a shielded cancel scope.
+
+        If the task has already finished, this method has no effect.
+        """
+        if not self._finished_event.is_set():
+            self._cancel_scope.cancel()
+
+    @property
+    def coro(self) -> Coroutine[Any, Any, T_co]:
+        """
+        The coroutine object that was passed to one of the task-spawning methods in
+        :class:`TaskGroup`.
+        """
+        return self._coro
+
+    @property
+    def status(self) -> TaskHandle.Status:
+        """
+        The current status of the task.
+
+        Every task starts in the :attr:`~TaskHandle.Status.PENDING` state.
+        If a task is cancelled while in this state, it will transition to the
+        :attr:`~TaskHandle.Status.CANCELLING` state. When the task finishes, it will
+        transition to one of the three final states (
+        :attr:`~TaskHandle.Status.FINISHED`, :attr:`~TaskHandle.Status.FAILED`, or
+        :attr:`~TaskHandle.Status.CANCELLING`) depending on the exception the task
+        raised, if any. No other status transitions will happen.
+        """
+        if not self._finished_event.is_set():
+            if self._cancel_scope.cancel_called:
+                return TaskHandle.Status.CANCELLING
+            else:
+                return TaskHandle.Status.PENDING
+        elif self._exception is not None:
+            if isinstance(self._exception, get_cancelled_exc_class()):
+                return TaskHandle.Status.CANCELLED
+            else:
+                return TaskHandle.Status.FAILED
+        else:
+            return TaskHandle.Status.FINISHED
+
+    @property
+    def name(self) -> str:
+        """The name of the task."""
+        return self._name
+
+    @property
+    def exception(self) -> BaseException | None:
+        """
+        The exception raised by the task, or ``None`` if it finished without raising.
+
+        :raises TaskNotFinished: if the task has not finished yet
+        :raises TaskCancelled: if the task was cancelled
+
+        """
+        match self.status:
+            case TaskHandle.Status.PENDING:
+                raise TaskNotFinished("the task has not finished yet")
+            case TaskHandle.Status.FINISHED:
+                return None
+            case TaskHandle.Status.CANCELLING:
+                raise TaskCancelled("the task was cancelled")
+            case TaskHandle.Status.CANCELLED:
+                raise TaskCancelled("the task was cancelled") from self._exception
+            case TaskHandle.Status.FAILED:
+                return self._exception
+
+    @property
+    def return_value(self) -> T_co:
+        """
+        The return value of the task.
+
+        :raises TaskNotFinished: if the task has not finished yet
+        :raises TaskCancelled: if the task was cancelled
+        :raises TaskFailed: if the task raised an exception
+
+        """
+        match self.status:
+            case TaskHandle.Status.PENDING:
+                raise TaskNotFinished("the task has not finished yet")
+            case TaskHandle.Status.FINISHED:
+                return self._return_value
+            case TaskHandle.Status.CANCELLING:
+                raise TaskCancelled("the task was cancelled")
+            case TaskHandle.Status.CANCELLED:
+                raise TaskCancelled("the task was cancelled") from self._exception
+            case TaskHandle.Status.FAILED:
+                raise TaskFailed("the task raised an exception") from self._exception
+
+    @property
+    def start_value(self) -> T_startval_co:
+        """
+        The value passed to :meth:`task_status.started() <.abc.TaskStatus.started>`,
+
+        :raises RuntimeError: if the task was not started with :meth:`TaskGroup.start()
+            <.abc.TaskGroup.start>`
+        """
+        try:
+            return self._start_value
+        except AttributeError:
+            raise RuntimeError(
+                "the task was not started with TaskGroup.start()"
+            ) from None
+
+    async def wait(self) -> None:
+        """
+        Wait for the task to finish.
+
+        This method will return as soon as the task has finished, no matter how it
+        happened.
+        """
+        await self._finished_event.wait()
+
+    def __await__(self) -> Generator[Any, Any, T_co]:
+        yield from self._finished_event.wait().__await__()
+        return self.return_value
+
+    def __repr__(self) -> str:
+        return (
+            f"<{self.__class__.__name__} {self.status.name.lower()} "
+            f"name={self._name!r} coro={self._coro!r}>"
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tempfile.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tempfile.py
new file mode 100644
index 0000000000000000000000000000000000000000..96030867befb177e754f596efcc3e9ee1f234442
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_tempfile.py
@@ -0,0 +1,615 @@
+from __future__ import annotations
+
+import os
+import sys
+import tempfile
+from collections.abc import Iterable
+from io import BytesIO, TextIOWrapper
+from types import TracebackType
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AnyStr,
+    Generic,
+    overload,
+)
+
+from .. import to_thread
+from .._core._fileio import AsyncFile
+from ..lowlevel import checkpoint_if_cancelled
+from ._tasks import CancelScope
+
+if TYPE_CHECKING:
+    from _typeshed import OpenBinaryMode, OpenTextMode, ReadableBuffer, WriteableBuffer
+
+
+class TemporaryFile(Generic[AnyStr]):
+    """
+    An asynchronous temporary file that is automatically created and cleaned up.
+
+    This class provides an asynchronous context manager interface to a temporary file.
+    The file is created using Python's standard `tempfile.TemporaryFile` function in a
+    background thread, and is wrapped as an asynchronous file using `AsyncFile`.
+
+    :param mode: The mode in which the file is opened. Defaults to "w+b".
+    :param buffering: The buffering policy (-1 means the default buffering).
+    :param encoding: The encoding used to decode or encode the file. Only applicable in
+        text mode.
+    :param newline: Controls how universal newlines mode works (only applicable in text
+        mode).
+    :param suffix: The suffix for the temporary file name.
+    :param prefix: The prefix for the temporary file name.
+    :param dir: The directory in which the temporary file is created.
+    :param errors: The error handling scheme used for encoding/decoding errors.
+    """
+
+    _async_file: AsyncFile[AnyStr]
+
+    @overload
+    def __init__(
+        self: TemporaryFile[bytes],
+        mode: OpenBinaryMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        *,
+        errors: str | None = ...,
+    ): ...
+    @overload
+    def __init__(
+        self: TemporaryFile[str],
+        mode: OpenTextMode,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        *,
+        errors: str | None = ...,
+    ): ...
+
+    def __init__(
+        self,
+        mode: OpenTextMode | OpenBinaryMode = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        errors: str | None = None,
+    ) -> None:
+        self.mode = mode
+        self.buffering = buffering
+        self.encoding = encoding
+        self.newline = newline
+        self.suffix: str | None = suffix
+        self.prefix: str | None = prefix
+        self.dir: str | None = dir
+        self.errors = errors
+
+    async def __aenter__(self) -> AsyncFile[AnyStr]:
+        fp = await to_thread.run_sync(
+            lambda: tempfile.TemporaryFile(
+                self.mode,
+                self.buffering,
+                self.encoding,
+                self.newline,
+                self.suffix,
+                self.prefix,
+                self.dir,
+                errors=self.errors,
+            )
+        )
+        self._async_file = AsyncFile(fp)
+        return self._async_file
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self._async_file.aclose()
+
+
+class NamedTemporaryFile(Generic[AnyStr]):
+    """
+    An asynchronous named temporary file that is automatically created and cleaned up.
+
+    This class provides an asynchronous context manager for a temporary file with a
+    visible name in the file system. It uses Python's standard
+    :func:`~tempfile.NamedTemporaryFile` function and wraps the file object with
+    :class:`AsyncFile` for asynchronous operations.
+
+    :param mode: The mode in which the file is opened. Defaults to "w+b".
+    :param buffering: The buffering policy (-1 means the default buffering).
+    :param encoding: The encoding used to decode or encode the file. Only applicable in
+        text mode.
+    :param newline: Controls how universal newlines mode works (only applicable in text
+        mode).
+    :param suffix: The suffix for the temporary file name.
+    :param prefix: The prefix for the temporary file name.
+    :param dir: The directory in which the temporary file is created.
+    :param delete: Whether to delete the file when it is closed.
+    :param errors: The error handling scheme used for encoding/decoding errors.
+    :param delete_on_close: (Python 3.12+) Whether to delete the file on close.
+    """
+
+    _async_file: AsyncFile[AnyStr]
+
+    @overload
+    def __init__(
+        self: NamedTemporaryFile[bytes],
+        mode: OpenBinaryMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        delete: bool = ...,
+        *,
+        errors: str | None = ...,
+        delete_on_close: bool = ...,
+    ): ...
+    @overload
+    def __init__(
+        self: NamedTemporaryFile[str],
+        mode: OpenTextMode,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        delete: bool = ...,
+        *,
+        errors: str | None = ...,
+        delete_on_close: bool = ...,
+    ): ...
+
+    def __init__(
+        self,
+        mode: OpenBinaryMode | OpenTextMode = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        delete: bool = True,
+        *,
+        errors: str | None = None,
+        delete_on_close: bool = True,
+    ) -> None:
+        self._params: dict[str, Any] = {
+            "mode": mode,
+            "buffering": buffering,
+            "encoding": encoding,
+            "newline": newline,
+            "suffix": suffix,
+            "prefix": prefix,
+            "dir": dir,
+            "delete": delete,
+            "errors": errors,
+        }
+        if sys.version_info >= (3, 12):
+            self._params["delete_on_close"] = delete_on_close
+
+    async def __aenter__(self) -> AsyncFile[AnyStr]:
+        fp = await to_thread.run_sync(
+            lambda: tempfile.NamedTemporaryFile(**self._params)
+        )
+        self._async_file = AsyncFile(fp)
+        return self._async_file
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self._async_file.aclose()
+
+
+class SpooledTemporaryFile(AsyncFile[AnyStr]):
+    """
+    An asynchronous spooled temporary file that starts in memory and is spooled to disk.
+
+    This class provides an asynchronous interface to a spooled temporary file, much like
+    Python's standard :class:`~tempfile.SpooledTemporaryFile`. It supports asynchronous
+    write operations and provides a method to force a rollover to disk.
+
+    :param max_size: Maximum size in bytes before the file is rolled over to disk.
+    :param mode: The mode in which the file is opened. Defaults to "w+b".
+    :param buffering: The buffering policy (-1 means the default buffering).
+    :param encoding: The encoding used to decode or encode the file (text mode only).
+    :param newline: Controls how universal newlines mode works (text mode only).
+    :param suffix: The suffix for the temporary file name.
+    :param prefix: The prefix for the temporary file name.
+    :param dir: The directory in which the temporary file is created.
+    :param errors: The error handling scheme used for encoding/decoding errors.
+    """
+
+    _rolled: bool = False
+
+    @overload
+    def __init__(
+        self: SpooledTemporaryFile[bytes],
+        max_size: int = ...,
+        mode: OpenBinaryMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        *,
+        errors: str | None = ...,
+    ): ...
+    @overload
+    def __init__(
+        self: SpooledTemporaryFile[str],
+        max_size: int = ...,
+        mode: OpenTextMode = ...,
+        buffering: int = ...,
+        encoding: str | None = ...,
+        newline: str | None = ...,
+        suffix: str | None = ...,
+        prefix: str | None = ...,
+        dir: str | None = ...,
+        *,
+        errors: str | None = ...,
+    ): ...
+
+    def __init__(
+        self,
+        max_size: int = 0,
+        mode: OpenBinaryMode | OpenTextMode = "w+b",
+        buffering: int = -1,
+        encoding: str | None = None,
+        newline: str | None = None,
+        suffix: str | None = None,
+        prefix: str | None = None,
+        dir: str | None = None,
+        *,
+        errors: str | None = None,
+    ) -> None:
+        self._tempfile_params: dict[str, Any] = {
+            "mode": mode,
+            "buffering": buffering,
+            "encoding": encoding,
+            "newline": newline,
+            "suffix": suffix,
+            "prefix": prefix,
+            "dir": dir,
+            "errors": errors,
+        }
+        self._max_size = max_size
+        if "b" in mode:
+            super().__init__(BytesIO())  # type: ignore[arg-type]
+        else:
+            super().__init__(
+                TextIOWrapper(  # type: ignore[arg-type]
+                    BytesIO(),
+                    encoding=encoding,
+                    errors=errors,
+                    newline=newline,
+                    write_through=True,
+                )
+            )
+
+    async def aclose(self) -> None:
+        if not self._rolled:
+            self._fp.close()
+            return
+
+        await super().aclose()
+
+    async def _check(self) -> None:
+        if self._rolled or self._fp.tell() <= self._max_size:
+            return
+
+        await self.rollover()
+
+    async def rollover(self) -> None:
+        if self._rolled:
+            return
+
+        self._rolled = True
+        buffer = self._fp
+        buffer.seek(0)
+        self._fp = await to_thread.run_sync(
+            lambda: tempfile.TemporaryFile(**self._tempfile_params)
+        )
+        await self.write(buffer.read())
+        buffer.close()
+
+    @property
+    def closed(self) -> bool:
+        return self._fp.closed
+
+    async def read(self, size: int = -1) -> AnyStr:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.read(size)
+
+        return await super().read(size)  # type: ignore[return-value]
+
+    async def read1(self: SpooledTemporaryFile[bytes], size: int = -1) -> bytes:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.read1(size)
+
+        return await super().read1(size)
+
+    async def readline(self) -> AnyStr:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.readline()
+
+        return await super().readline()  # type: ignore[return-value]
+
+    async def readlines(self) -> list[AnyStr]:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.readlines()
+
+        return await super().readlines()  # type: ignore[return-value]
+
+    async def readinto(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.readinto(b)
+
+        return await super().readinto(b)
+
+    async def readinto1(self: SpooledTemporaryFile[bytes], b: WriteableBuffer) -> int:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.readinto1(b)
+
+        return await super().readinto1(b)
+
+    async def seek(self, offset: int, whence: int | None = os.SEEK_SET) -> int:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.seek(offset, whence)
+
+        return await super().seek(offset, whence)
+
+    async def tell(self) -> int:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.tell()
+
+        return await super().tell()
+
+    async def truncate(self, size: int | None = None) -> int:
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            return self._fp.truncate(size)
+
+        return await super().truncate(size)
+
+    @overload
+    async def write(self: SpooledTemporaryFile[bytes], b: ReadableBuffer) -> int: ...
+    @overload
+    async def write(self: SpooledTemporaryFile[str], b: str) -> int: ...
+
+    async def write(self, b: ReadableBuffer | str) -> int:
+        """
+        Asynchronously write data to the spooled temporary file.
+
+        If the file has not yet been rolled over, the data is written synchronously,
+        and a rollover is triggered if the size exceeds the maximum size.
+
+        :param s: The data to write.
+        :return: The number of bytes written.
+        :raises RuntimeError: If the underlying file is not initialized.
+
+        """
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            result = self._fp.write(b)
+            await self._check()
+            return result
+
+        return await super().write(b)  # type: ignore[misc]
+
+    @overload
+    async def writelines(
+        self: SpooledTemporaryFile[bytes], lines: Iterable[ReadableBuffer]
+    ) -> None: ...
+    @overload
+    async def writelines(
+        self: SpooledTemporaryFile[str], lines: Iterable[str]
+    ) -> None: ...
+
+    async def writelines(self, lines: Iterable[str] | Iterable[ReadableBuffer]) -> None:
+        """
+        Asynchronously write a list of lines to the spooled temporary file.
+
+        If the file has not yet been rolled over, the lines are written synchronously,
+        and a rollover is triggered if the size exceeds the maximum size.
+
+        :param lines: An iterable of lines to write.
+        :raises RuntimeError: If the underlying file is not initialized.
+
+        """
+        if not self._rolled:
+            await checkpoint_if_cancelled()
+            result = self._fp.writelines(lines)
+            await self._check()
+            return result
+
+        return await super().writelines(lines)  # type: ignore[misc]
+
+
+class TemporaryDirectory(Generic[AnyStr]):
+    """
+    An asynchronous temporary directory that is created and cleaned up automatically.
+
+    This class provides an asynchronous context manager for creating a temporary
+    directory. It wraps Python's standard :class:`~tempfile.TemporaryDirectory` to
+    perform directory creation and cleanup operations in a background thread.
+
+    :param suffix: Suffix to be added to the temporary directory name.
+    :param prefix: Prefix to be added to the temporary directory name.
+    :param dir: The parent directory where the temporary directory is created.
+    :param ignore_cleanup_errors: Whether to ignore errors during cleanup
+    :param delete: Whether to delete the directory upon closing (Python 3.12+).
+    """
+
+    def __init__(
+        self,
+        suffix: AnyStr | None = None,
+        prefix: AnyStr | None = None,
+        dir: AnyStr | None = None,
+        *,
+        ignore_cleanup_errors: bool = False,
+        delete: bool = True,
+    ) -> None:
+        self.suffix: AnyStr | None = suffix
+        self.prefix: AnyStr | None = prefix
+        self.dir: AnyStr | None = dir
+        self.ignore_cleanup_errors = ignore_cleanup_errors
+        self.delete = delete
+
+        self._tempdir: tempfile.TemporaryDirectory | None = None
+
+    async def __aenter__(self) -> str:
+        params: dict[str, Any] = {
+            "suffix": self.suffix,
+            "prefix": self.prefix,
+            "dir": self.dir,
+            "ignore_cleanup_errors": self.ignore_cleanup_errors,
+        }
+        if sys.version_info >= (3, 12):
+            params["delete"] = self.delete
+
+        self._tempdir = await to_thread.run_sync(
+            lambda: tempfile.TemporaryDirectory(**params)
+        )
+        return await to_thread.run_sync(self._tempdir.__enter__)
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        if self._tempdir is not None:
+            with CancelScope(shield=True):
+                await to_thread.run_sync(
+                    self._tempdir.__exit__, exc_type, exc_value, traceback
+                )
+
+    async def cleanup(self) -> None:
+        if self._tempdir is not None:
+            await to_thread.run_sync(self._tempdir.cleanup)
+
+
+@overload
+async def mkstemp(
+    suffix: str | None = None,
+    prefix: str | None = None,
+    dir: str | None = None,
+    text: bool = False,
+) -> tuple[int, str]: ...
+
+
+@overload
+async def mkstemp(
+    suffix: bytes | None = None,
+    prefix: bytes | None = None,
+    dir: bytes | None = None,
+    text: bool = False,
+) -> tuple[int, bytes]: ...
+
+
+async def mkstemp(
+    suffix: AnyStr | None = None,
+    prefix: AnyStr | None = None,
+    dir: AnyStr | None = None,
+    text: bool = False,
+) -> tuple[int, str | bytes]:
+    """
+    Asynchronously create a temporary file and return an OS-level handle and the file
+    name.
+
+    This function wraps `tempfile.mkstemp` and executes it in a background thread.
+
+    :param suffix: Suffix to be added to the file name.
+    :param prefix: Prefix to be added to the file name.
+    :param dir: Directory in which the temporary file is created.
+    :param text: Whether the file is opened in text mode.
+    :return: A tuple containing the file descriptor and the file name.
+
+    """
+    return await to_thread.run_sync(tempfile.mkstemp, suffix, prefix, dir, text)
+
+
+@overload
+async def mkdtemp(
+    suffix: str | None = None,
+    prefix: str | None = None,
+    dir: str | None = None,
+) -> str: ...
+
+
+@overload
+async def mkdtemp(
+    suffix: bytes | None = None,
+    prefix: bytes | None = None,
+    dir: bytes | None = None,
+) -> bytes: ...
+
+
+async def mkdtemp(
+    suffix: AnyStr | None = None,
+    prefix: AnyStr | None = None,
+    dir: AnyStr | None = None,
+) -> str | bytes:
+    """
+    Asynchronously create a temporary directory and return its path.
+
+    This function wraps `tempfile.mkdtemp` and executes it in a background thread.
+
+    :param suffix: Suffix to be added to the directory name.
+    :param prefix: Prefix to be added to the directory name.
+    :param dir: Parent directory where the temporary directory is created.
+    :return: The path of the created temporary directory.
+
+    """
+    return await to_thread.run_sync(tempfile.mkdtemp, suffix, prefix, dir)
+
+
+async def gettempdir() -> str:
+    """
+    Asynchronously return the name of the directory used for temporary files.
+
+    This function wraps `tempfile.gettempdir` and executes it in a background thread.
+
+    :return: The path of the temporary directory as a string.
+
+    """
+    return await to_thread.run_sync(tempfile.gettempdir)
+
+
+async def gettempdirb() -> bytes:
+    """
+    Asynchronously return the name of the directory used for temporary files in bytes.
+
+    This function wraps `tempfile.gettempdirb` and executes it in a background thread.
+
+    :return: The path of the temporary directory as bytes.
+
+    """
+    return await to_thread.run_sync(tempfile.gettempdirb)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_testing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa2c3913709d4143d1967fc2857bb67be361f6db
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_testing.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from collections.abc import Awaitable, Generator
+from typing import Any, cast
+
+from ._eventloop import get_async_backend
+
+
+class TaskInfo:
+    """
+    Represents an asynchronous task.
+
+    :ivar int id: the unique identifier of the task
+    :ivar parent_id: the identifier of the parent task, if any
+    :vartype parent_id: Optional[int]
+    :ivar str name: the description of the task (if any)
+    :ivar ~collections.abc.Coroutine coro: the coroutine object of the task
+    """
+
+    __slots__ = "_name", "coro", "id", "name", "parent_id"
+
+    def __init__(
+        self,
+        id: int,
+        parent_id: int | None,
+        name: str | None,
+        coro: Generator[Any, Any, Any] | Awaitable[Any],
+    ):
+        func = get_current_task
+        self._name = f"{func.__module__}.{func.__qualname__}"
+        self.id: int = id
+        self.parent_id: int | None = parent_id
+        self.name: str | None = name
+        self.coro: Generator[Any, Any, Any] | Awaitable[Any] = coro
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, TaskInfo):
+            return self.id == other.id
+
+        return NotImplemented
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(id={self.id!r}, name={self.name!r})"
+
+    def has_pending_cancellation(self) -> bool:
+        """
+        Return ``True`` if the task has a cancellation pending, ``False`` otherwise.
+
+        """
+        return False
+
+
+def get_current_task() -> TaskInfo:
+    """
+    Return the current task.
+
+    :return: a representation of the current task
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().get_current_task()
+
+
+def get_running_tasks() -> list[TaskInfo]:
+    """
+    Return a list of running tasks in the current event loop.
+
+    :return: a list of task info objects
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return cast("list[TaskInfo]", get_async_backend().get_running_tasks())
+
+
+async def wait_all_tasks_blocked() -> None:
+    """Wait until all other tasks are waiting for something."""
+    await get_async_backend().wait_all_tasks_blocked()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_typedattr.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_typedattr.py
new file mode 100644
index 0000000000000000000000000000000000000000..59d3da9d8787d65295cffc3a1f43275f27d71772
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_core/_typedattr.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import sys
+from collections.abc import Callable, Mapping
+from typing import Any, TypeVar, final, overload
+
+from ._exceptions import TypedAttributeLookupError
+
+if sys.version_info < (3, 15):
+    from typing_extensions import sentinel
+
+T_Attr = TypeVar("T_Attr")
+T_Default = TypeVar("T_Default")
+undefined = sentinel("undefined")
+
+
+def typed_attribute() -> Any:
+    """Return a unique object, used to mark typed attributes."""
+    return object()
+
+
+class TypedAttributeSet:
+    """
+    Superclass for typed attribute collections.
+
+    Checks that every public attribute of every subclass has a type annotation.
+    """
+
+    def __init_subclass__(cls) -> None:
+        annotations: dict[str, Any] = getattr(cls, "__annotations__", {})
+        for attrname in dir(cls):
+            if not attrname.startswith("_") and attrname not in annotations:
+                raise TypeError(
+                    f"Attribute {attrname!r} is missing its type annotation"
+                )
+
+        super().__init_subclass__()
+
+
+class TypedAttributeProvider:
+    """Base class for classes that wish to provide typed extra attributes."""
+
+    @property
+    def extra_attributes(self) -> Mapping[T_Attr, Callable[[], T_Attr]]:
+        """
+        A mapping of the extra attributes to callables that return the corresponding
+        values.
+
+        If the provider wraps another provider, the attributes from that wrapper should
+        also be included in the returned mapping (but the wrapper may override the
+        callables from the wrapped instance).
+
+        """
+        return {}
+
+    @overload
+    def extra(self, attribute: T_Attr) -> T_Attr: ...
+
+    @overload
+    def extra(self, attribute: T_Attr, default: T_Default) -> T_Attr | T_Default: ...
+
+    @final
+    def extra(self, attribute: Any, default: object = undefined) -> object:
+        """
+        extra(attribute, default=undefined)
+
+        Return the value of the given typed extra attribute.
+
+        :param attribute: the attribute (member of a :class:`~TypedAttributeSet`) to
+            look for
+        :param default: the value that should be returned if no value is found for the
+            attribute
+        :raises ~anyio.TypedAttributeLookupError: if the search failed and no default
+            value was given
+
+        """
+        try:
+            getter = self.extra_attributes[attribute]
+        except KeyError:
+            if default is undefined:
+                raise TypedAttributeLookupError("Attribute not found") from None
+            else:
+                return default
+
+        return getter()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_lazyimport.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_lazyimport.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc0a4faba7009d3fb542842cce1c0eec1c568440
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/_lazyimport.py
@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+__all__ = (
+    "fix_package_names",
+    "install_lazy_importer",
+    "set_deprecated_aliases",
+)
+
+import ast
+import inspect
+import sys
+import warnings
+from importlib import import_module
+from types import ModuleType
+from typing import Any
+
+
+def install_lazy_importer() -> bool:
+    module_globals = sys._getframe(1).f_globals
+    module_name = module_globals["__name__"]
+    module_prefix = module_name + "."
+    module = sys.modules[module_name]
+    lazy_map, deprecated_aliases, submodule_names = _build_lazy_map(module)
+    names = sorted(lazy_map)
+
+    # Delete symbols that are not part of the API
+    del module_globals["TYPE_CHECKING"]
+    del module_globals["install_lazy_importer"]
+
+    if not lazy_map and not deprecated_aliases:
+        return False
+
+    def __getattr__(name: str) -> Any:
+        if new_name := deprecated_aliases.get(name):
+            emit_deprecation_warning(module_name, name, new_name)
+            target_mod, target_attr = new_name.rsplit(".", 1)
+        elif name in submodule_names:
+            target_mod, target_attr = "." + name, ""
+        else:
+            try:
+                target_mod, target_attr = lazy_map[name]
+            except KeyError:
+                raise AttributeError(
+                    f"module {module_name!r} has no attribute {name!r}"
+                ) from None
+
+        imported = import_module(target_mod, module_name)
+        value = getattr(imported, target_attr) if target_attr else imported
+
+        # patch the module name to match
+        if (
+            getattr(value, "__module__", "").startswith(module_prefix)
+            and name not in deprecated_aliases
+        ):
+            value.__module__ = module_name
+
+        module_globals[name] = value
+        return value
+
+    def __dir__() -> list[str]:
+        return names
+
+    module_globals["__dir__"] = __dir__
+    module_globals["__getattr__"] = __getattr__
+    module_globals.pop("fix_package_names", None)
+    module_globals.pop("set_deprecated_aliases", None)
+    return True
+
+
+def fix_package_names() -> None:
+    module_globals = sys._getframe(1).f_globals
+    module_prefix = module_globals["__name__"] + "."
+    del module_globals[fix_package_names.__name__]
+    for value in module_globals.values():
+        if modname := getattr(value, "__module__", ""):
+            if modname.startswith(module_prefix):
+                parts = modname.split(".")
+                value.__module__ = ".".join(
+                    part for part in parts if not part.startswith("_")
+                )
+
+
+def emit_deprecation_warning(module_name: str, name: str, target: str) -> None:
+    warnings.warn(
+        f"The {module_name}.{name} alias is deprecated, use {target} instead.",
+        DeprecationWarning,
+        stacklevel=3,
+    )
+
+
+def set_deprecated_aliases(aliases: dict[str, str]) -> None:
+    module_globals = sys._getframe(1).f_globals
+    module_name = module_globals["__name__"]
+    del module_globals[set_deprecated_aliases.__name__]
+
+    def __getattr__(name: str) -> Any:
+        try:
+            target = aliases[name]
+        except KeyError:
+            raise AttributeError(
+                f"module {module_name!r} has no attribute {name!r}"
+            ) from None
+
+        emit_deprecation_warning(module_name, name, target)
+        target_modname, attrname = target.rsplit(".", 1)
+        module = import_module(target_modname)
+        return getattr(module, attrname)
+
+    sys.modules[module_name].__dict__["__getattr__"] = __getattr__
+
+
+def _build_lazy_map(
+    module: ModuleType,
+) -> tuple[dict[str, tuple[str, str]], dict[str, str], list[str]]:
+    try:
+        source = inspect.getsource(module)
+    except OSError:
+        return {}, {}, []
+
+    tree = compile(source, module.__file__ or "", "exec", ast.PyCF_ONLY_AST)
+    assert isinstance(tree, ast.Module)
+    out: dict[str, tuple[str, str]] = {}
+    deprecated_aliases: dict[str, str] = {}
+    submodule_names: list[str] = []
+
+    for node in tree.body:
+        if not isinstance(node, ast.If) or not _is_type_checking_block(node.test):
+            continue
+
+        for stmt in node.body:
+            match stmt:
+                case ast.ImportFrom():
+                    if stmt.module is None:
+                        submodule_names.extend(alias.name for alias in stmt.names)
+                    else:
+                        base = "." * stmt.level + (stmt.module or "")
+                        for alias in stmt.names:
+                            if alias.name == "*":
+                                raise RuntimeError("star imports not supported")
+
+                            exported = alias.asname or alias.name
+                            out[exported] = (base, alias.name)
+                case ast.Expr() if isinstance(stmt.value, ast.Call):
+                    call = stmt.value
+                    if (
+                        isinstance(call.func, ast.Name)
+                        and call.func.id == "set_deprecated_aliases"
+                    ):
+                        arg0 = call.args[0]
+                        assert isinstance(arg0, ast.Dict)
+                        for key, value in zip(arg0.keys, arg0.values, strict=True):
+                            assert isinstance(key, ast.Constant)
+                            assert isinstance(key.value, str)
+                            assert isinstance(value, ast.Constant)
+                            assert isinstance(value.value, str)
+                            deprecated_aliases[key.value] = value.value
+
+    return out, deprecated_aliases, submodule_names
+
+
+def _is_type_checking_block(test: ast.AST) -> bool:
+    if not isinstance(test, ast.BoolOp):
+        return False
+
+    subtest = test.values[0]
+    match subtest:
+        case ast.Name():
+            return subtest.id == "TYPE_CHECKING"
+        case ast.Attribute():
+            return (
+                isinstance(subtest.value, ast.Name)
+                and subtest.value.id == "typing"
+                and subtest.attr == "TYPE_CHECKING"
+            )
+        case _:
+            return False
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ba738f87f2fc778f5bb4c87fa1251a42afd22529
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__init__.py
@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from .._lazyimport import (
+    fix_package_names,
+    install_lazy_importer,
+    set_deprecated_aliases,
+)
+
+if TYPE_CHECKING or not install_lazy_importer():
+    from ._eventloop import AsyncBackend as AsyncBackend
+    from ._resources import AsyncResource as AsyncResource
+    from ._sockets import ConnectedUDPSocket as ConnectedUDPSocket
+    from ._sockets import ConnectedUNIXDatagramSocket as ConnectedUNIXDatagramSocket
+    from ._sockets import IPAddressType as IPAddressType
+    from ._sockets import IPSockAddrType as IPSockAddrType
+    from ._sockets import SocketAttribute as SocketAttribute
+    from ._sockets import SocketListener as SocketListener
+    from ._sockets import SocketStream as SocketStream
+    from ._sockets import UDPPacketType as UDPPacketType
+    from ._sockets import UDPSocket as UDPSocket
+    from ._sockets import UNIXDatagramPacketType as UNIXDatagramPacketType
+    from ._sockets import UNIXDatagramSocket as UNIXDatagramSocket
+    from ._sockets import UNIXSocketStream as UNIXSocketStream
+    from ._streams import AnyByteReceiveStream as AnyByteReceiveStream
+    from ._streams import AnyByteSendStream as AnyByteSendStream
+    from ._streams import AnyByteStream as AnyByteStream
+    from ._streams import AnyByteStreamConnectable as AnyByteStreamConnectable
+    from ._streams import (
+        AnyUnreliableByteReceiveStream as AnyUnreliableByteReceiveStream,
+    )
+    from ._streams import AnyUnreliableByteSendStream as AnyUnreliableByteSendStream
+    from ._streams import AnyUnreliableByteStream as AnyUnreliableByteStream
+    from ._streams import ByteReceiveStream as ByteReceiveStream
+    from ._streams import ByteSendStream as ByteSendStream
+    from ._streams import ByteStream as ByteStream
+    from ._streams import ByteStreamConnectable as ByteStreamConnectable
+    from ._streams import Listener as Listener
+    from ._streams import ObjectReceiveStream as ObjectReceiveStream
+    from ._streams import ObjectSendStream as ObjectSendStream
+    from ._streams import ObjectStream as ObjectStream
+    from ._streams import ObjectStreamConnectable as ObjectStreamConnectable
+    from ._streams import UnreliableObjectReceiveStream as UnreliableObjectReceiveStream
+    from ._streams import UnreliableObjectSendStream as UnreliableObjectSendStream
+    from ._streams import UnreliableObjectStream as UnreliableObjectStream
+    from ._subprocesses import Process as Process
+    from ._tasks import TaskGroup as TaskGroup
+    from ._tasks import TaskStatus as TaskStatus
+    from ._testing import TestRunner as TestRunner
+
+    fix_package_names()
+    set_deprecated_aliases(
+        {
+            "CapacityLimiter": "anyio.CapacityLimiter",
+            "Condition": "anyio.Condition",
+            "Event": "anyio.Event",
+            "Lock": "anyio.Lock",
+            "Semaphore": "anyio.Semaphore",
+            "CancelScope": "anyio.CancelScope",
+            "BlockingPortal": "anyio.from_thread.BlockingPortal",
+        }
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cb43b89454a2fb861b16657ed5eecf7418e879ae
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_eventloop.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_eventloop.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c5413fc35a1eaaeedae723a0cb11ad86f46f487c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_eventloop.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_resources.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_resources.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..62860b1525f06fc23ab8a3d3666846f7ee613310
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_resources.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_sockets.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_sockets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c1227b0fae3964976f2b79d71d31703b1878870
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_sockets.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_streams.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_streams.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..14e70cb36bf726872120d047e9cd9d2c4d7d5bc7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_streams.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..260e7dfd81c8f5cae39fe76d6962874d28a92e1d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_subprocesses.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_tasks.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_tasks.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d9c696f12ca8d927083dc0ef5d28984cc730117c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_tasks.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_testing.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_testing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd1bc74761deb9fd433224597012a120db9985bf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/__pycache__/_testing.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_eventloop.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_eventloop.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3cbed2febe41bbff583c80bc1442daee3862e8b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_eventloop.py
@@ -0,0 +1,428 @@
+from __future__ import annotations
+
+import math
+import sys
+from abc import ABCMeta, abstractmethod
+from collections.abc import (
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Iterable,
+    Mapping,
+    Sequence,
+)
+from contextlib import AbstractContextManager
+from os import PathLike
+from signal import Signals
+from socket import AddressFamily, SocketKind, socket
+from typing import (
+    IO,
+    TYPE_CHECKING,
+    Any,
+    TypeAlias,
+    TypeVar,
+    overload,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if TYPE_CHECKING:
+    from _typeshed import FileDescriptorLike
+
+    from .._core._synchronization import CapacityLimiter, Event, Lock, Semaphore
+    from .._core._tasks import CancelScope
+    from .._core._testing import TaskInfo
+    from ._sockets import (
+        ConnectedUDPSocket,
+        ConnectedUNIXDatagramSocket,
+        IPSockAddrType,
+        SocketListener,
+        SocketStream,
+        UDPSocket,
+        UNIXDatagramSocket,
+        UNIXSocketStream,
+    )
+    from ._subprocesses import Process
+    from ._tasks import TaskGroup
+    from ._testing import TestRunner
+
+T_Retval = TypeVar("T_Retval")
+T_co = TypeVar("T_co", covariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
+StrOrBytesPath: TypeAlias = str | bytes | PathLike[str] | PathLike[bytes]
+
+
+class AsyncBackend(metaclass=ABCMeta):
+    @classmethod
+    @abstractmethod
+    def run(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        options: dict[str, Any],
+    ) -> T_Retval:
+        """
+        Run the given coroutine function in an asynchronous event loop.
+
+        The current thread must not be already running an event loop.
+
+        :param func: a coroutine function
+        :param args: positional arguments to ``func``
+        :param kwargs: positional arguments to ``func``
+        :param options: keyword arguments to call the backend ``run()`` implementation
+            with
+        :return: the return value of the coroutine function
+        """
+
+    @classmethod
+    @abstractmethod
+    def current_token(cls) -> object:
+        """
+        Return an object that allows other threads to run code inside the event loop.
+
+        :return: a token object, specific to the event loop running in the current
+            thread
+        """
+
+    @classmethod
+    @abstractmethod
+    def current_time(cls) -> float:
+        """
+        Return the current value of the event loop's internal clock.
+
+        :return: the clock value (seconds)
+        """
+
+    @classmethod
+    @abstractmethod
+    def cancelled_exception_class(cls) -> type[BaseException]:
+        """Return the exception class that is raised in a task if it's cancelled."""
+
+    @classmethod
+    @abstractmethod
+    async def checkpoint(cls) -> None:
+        """
+        Check if the task has been cancelled, and allow rescheduling of other tasks.
+
+        This is effectively the same as running :meth:`checkpoint_if_cancelled` and then
+        :meth:`cancel_shielded_checkpoint`.
+        """
+
+    @classmethod
+    async def checkpoint_if_cancelled(cls) -> None:
+        """
+        Check if the current task group has been cancelled.
+
+        This will check if the task has been cancelled, but will not allow other tasks
+        to be scheduled if not.
+
+        """
+        if cls.current_effective_deadline() == -math.inf:
+            await cls.checkpoint()
+
+    @classmethod
+    async def cancel_shielded_checkpoint(cls) -> None:
+        """
+        Allow the rescheduling of other tasks.
+
+        This will give other tasks the opportunity to run, but without checking if the
+        current task group has been cancelled, unlike with :meth:`checkpoint`.
+
+        """
+        with cls.create_cancel_scope(shield=True):
+            await cls.sleep(0)
+
+    @classmethod
+    @abstractmethod
+    async def sleep(cls, delay: float) -> None:
+        """
+        Pause the current task for the specified duration.
+
+        :param delay: the duration, in seconds
+        """
+
+    @classmethod
+    @abstractmethod
+    def create_cancel_scope(
+        cls, *, deadline: float = math.inf, shield: bool = False
+    ) -> CancelScope:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def current_effective_deadline(cls) -> float:
+        """
+        Return the nearest deadline among all the cancel scopes effective for the
+        current task.
+
+        :return:
+            - a clock value from the event loop's internal clock
+            - ``inf`` if there is no deadline in effect
+            - ``-inf`` if the current scope has been cancelled
+        :rtype: float
+        """
+
+    @classmethod
+    @abstractmethod
+    def create_task_group(cls) -> TaskGroup:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_event(cls) -> Event:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_lock(cls, *, fast_acquire: bool) -> Lock:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_semaphore(
+        cls,
+        initial_value: int,
+        *,
+        max_value: int | None = None,
+        fast_acquire: bool = False,
+    ) -> Semaphore:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_capacity_limiter(cls, total_tokens: float) -> CapacityLimiter:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def run_sync_in_worker_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        abandon_on_cancel: bool = False,
+        limiter: CapacityLimiter | None = None,
+    ) -> T_Retval:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def check_cancelled(cls) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def run_async_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_co:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def run_sync_from_thread(
+        cls,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        token: object,
+    ) -> T_Retval:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def open_process(
+        cls,
+        command: StrOrBytesPath | Sequence[StrOrBytesPath],
+        *,
+        stdin: int | IO[Any] | None,
+        stdout: int | IO[Any] | None,
+        stderr: int | IO[Any] | None,
+        cwd: StrOrBytesPath | None = None,
+        env: Mapping[str, str] | None = None,
+        startupinfo: Any = None,
+        creationflags: int = 0,
+        start_new_session: bool = False,
+        pass_fds: Sequence[int] = (),
+        user: str | int | None = None,
+        group: str | int | None = None,
+        extra_groups: Iterable[str | int] | None = None,
+        umask: int = -1,
+        **kwargs: Any,
+    ) -> Process:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def setup_process_pool_exit_at_shutdown(cls, workers: set[Process]) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def connect_tcp(
+        cls, host: str, port: int, local_address: IPSockAddrType | None = None
+    ) -> SocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def connect_unix(cls, path: str | bytes) -> UNIXSocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_tcp_listener(cls, sock: socket) -> SocketListener:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_unix_listener(cls, sock: socket) -> SocketListener:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def create_udp_socket(
+        cls,
+        family: AddressFamily,
+        local_address: IPSockAddrType | None,
+        remote_address: IPSockAddrType | None,
+        reuse_port: bool,
+    ) -> UDPSocket | ConnectedUDPSocket:
+        pass
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: None
+    ) -> UNIXDatagramSocket: ...
+
+    @classmethod
+    @overload
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: str | bytes
+    ) -> ConnectedUNIXDatagramSocket: ...
+
+    @classmethod
+    @abstractmethod
+    async def create_unix_datagram_socket(
+        cls, raw_socket: socket, remote_path: str | bytes | None
+    ) -> UNIXDatagramSocket | ConnectedUNIXDatagramSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def getaddrinfo(
+        cls,
+        host: bytes | str | None,
+        port: str | int | None,
+        *,
+        family: int | AddressFamily = 0,
+        type: int | SocketKind = 0,
+        proto: int = 0,
+        flags: int = 0,
+    ) -> Sequence[
+        tuple[
+            AddressFamily,
+            SocketKind,
+            int,
+            str,
+            tuple[str, int] | tuple[str, int, int, int] | tuple[int, bytes],
+        ]
+    ]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def getnameinfo(
+        cls, sockaddr: IPSockAddrType, flags: int = 0
+    ) -> tuple[str, str]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_readable(cls, obj: FileDescriptorLike) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_writable(cls, obj: FileDescriptorLike) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def notify_closing(cls, obj: FileDescriptorLike) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_listener_socket(cls, sock: socket) -> SocketListener:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_stream_socket(cls, sock: socket) -> SocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_unix_stream_socket(cls, sock: socket) -> UNIXSocketStream:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_udp_socket(cls, sock: socket) -> UDPSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_connected_udp_socket(cls, sock: socket) -> ConnectedUDPSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_unix_datagram_socket(cls, sock: socket) -> UNIXDatagramSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wrap_connected_unix_datagram_socket(
+        cls, sock: socket
+    ) -> ConnectedUNIXDatagramSocket:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def current_default_thread_limiter(cls) -> CapacityLimiter:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def open_signal_receiver(
+        cls, *signals: Signals
+    ) -> AbstractContextManager[AsyncIterator[Signals]]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_current_task(cls) -> TaskInfo:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_running_tasks(cls) -> Sequence[TaskInfo]:
+        pass
+
+    @classmethod
+    @abstractmethod
+    async def wait_all_tasks_blocked(cls) -> None:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def create_test_runner(cls, options: dict[str, Any]) -> TestRunner:
+        pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_resources.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_resources.py
new file mode 100644
index 0000000000000000000000000000000000000000..9373f71a3fc4ccfb2002d03328cf62f78802375a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_resources.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import sys
+from abc import ABCMeta, abstractmethod
+from types import TracebackType
+from typing import TypeVar
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+T = TypeVar("T")
+
+
+class AsyncResource(metaclass=ABCMeta):
+    """
+    Abstract base class for all closeable asynchronous resources.
+
+    Works as an asynchronous context manager which returns the instance itself on enter,
+    and calls :meth:`aclose` on exit.
+    """
+
+    __slots__ = ()
+
+    async def __aenter__(self) -> Self:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        await self.aclose()
+
+    @abstractmethod
+    async def aclose(self) -> None:
+        """Close the resource."""
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_sockets.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_sockets.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6a1139dfd9d31776c581b25db1309d9bfbb080e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_sockets.py
@@ -0,0 +1,401 @@
+from __future__ import annotations
+
+import errno
+import socket
+from abc import abstractmethod
+from collections.abc import Callable, Collection, Mapping
+from contextlib import AsyncExitStack
+from io import IOBase
+from ipaddress import IPv4Address, IPv6Address
+from socket import AddressFamily
+from typing import TYPE_CHECKING, Any, TypeAlias, TypeVar
+
+from .._core._eventloop import get_async_backend
+from .._core._typedattr import (
+    TypedAttributeProvider,
+    TypedAttributeSet,
+    typed_attribute,
+)
+from ._streams import ByteStream, Listener, UnreliableObjectStream
+
+if TYPE_CHECKING:
+    from ._tasks import TaskGroup
+
+IPAddressType: TypeAlias = str | IPv4Address | IPv6Address
+IPSockAddrType: TypeAlias = tuple[str, int]
+SockAddrType: TypeAlias = IPSockAddrType | str
+UDPPacketType: TypeAlias = tuple[bytes, IPSockAddrType]
+UNIXDatagramPacketType: TypeAlias = tuple[bytes, str]
+T_Retval = TypeVar("T_Retval")
+
+
+def _validate_socket(
+    sock_or_fd: socket.socket | int,
+    sock_type: socket.SocketKind,
+    addr_family: socket.AddressFamily = socket.AF_UNSPEC,
+    *,
+    require_connected: bool = False,
+    require_bound: bool = False,
+) -> socket.socket:
+    if isinstance(sock_or_fd, int):
+        try:
+            sock = socket.socket(fileno=sock_or_fd)
+        except OSError as exc:
+            if exc.errno == errno.ENOTSOCK:
+                raise ValueError(
+                    "the file descriptor does not refer to a socket"
+                ) from exc
+            elif require_connected:
+                raise ValueError("the socket must be connected") from exc
+            elif require_bound:
+                raise ValueError("the socket must be bound to a local address") from exc
+            else:
+                raise
+    elif isinstance(sock_or_fd, socket.socket):
+        sock = sock_or_fd
+    else:
+        raise TypeError(
+            f"expected an int or socket, got {type(sock_or_fd).__qualname__} instead"
+        )
+
+    try:
+        if require_connected:
+            try:
+                sock.getpeername()
+            except OSError as exc:
+                raise ValueError("the socket must be connected") from exc
+
+        if require_bound:
+            try:
+                if sock.family in (socket.AF_INET, socket.AF_INET6):
+                    bound_addr = sock.getsockname()[1]
+                else:
+                    bound_addr = sock.getsockname()
+            except OSError:
+                bound_addr = None
+
+            if not bound_addr:
+                raise ValueError("the socket must be bound to a local address")
+
+        if addr_family != socket.AF_UNSPEC and sock.family != addr_family:
+            raise ValueError(
+                f"address family mismatch: expected {addr_family.name}, got "
+                f"{sock.family.name}"
+            )
+
+        if sock.type != sock_type:
+            raise ValueError(
+                f"socket type mismatch: expected {sock_type.name}, got {sock.type.name}"
+            )
+    except BaseException:
+        # Avoid ResourceWarning from the locally constructed socket object
+        if isinstance(sock_or_fd, int):
+            sock.detach()
+
+        raise
+
+    sock.setblocking(False)
+    return sock
+
+
+class SocketAttribute(TypedAttributeSet):
+    """
+    .. attribute:: family
+        :type: socket.AddressFamily
+
+        the address family of the underlying socket
+
+    .. attribute:: local_address
+        :type: tuple[str, int] | str
+
+        the local address the underlying socket is connected to
+
+    .. attribute:: local_port
+        :type: int
+
+        for IP based sockets, the local port the underlying socket is bound to
+
+    .. attribute:: raw_socket
+        :type: socket.socket
+
+        the underlying stdlib socket object
+
+    .. attribute:: remote_address
+        :type: tuple[str, int] | str
+
+        the remote address the underlying socket is connected to
+
+    .. attribute:: remote_port
+        :type: int
+
+        for IP based sockets, the remote port the underlying socket is connected to
+    """
+
+    family: AddressFamily = typed_attribute()
+    local_address: SockAddrType = typed_attribute()
+    local_port: int = typed_attribute()
+    raw_socket: socket.socket = typed_attribute()
+    remote_address: SockAddrType = typed_attribute()
+    remote_port: int = typed_attribute()
+
+
+class _SocketProvider(TypedAttributeProvider):
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        from .._core._sockets import convert_ipv6_sockaddr as convert
+
+        attributes: dict[Any, Callable[[], Any]] = {
+            SocketAttribute.family: lambda: self._raw_socket.family,
+            SocketAttribute.local_address: lambda: convert(
+                self._raw_socket.getsockname()
+            ),
+            SocketAttribute.raw_socket: lambda: self._raw_socket,
+        }
+        try:
+            peername: tuple[str, int] | None = convert(self._raw_socket.getpeername())
+        except OSError:
+            peername = None
+
+        # Provide the remote address for connected sockets
+        if peername is not None:
+            attributes[SocketAttribute.remote_address] = lambda: peername
+
+        # Provide local and remote ports for IP based sockets
+        if self._raw_socket.family in (AddressFamily.AF_INET, AddressFamily.AF_INET6):
+            attributes[SocketAttribute.local_port] = lambda: (
+                self._raw_socket.getsockname()[1]
+            )
+            if peername is not None:
+                remote_port = peername[1]
+                attributes[SocketAttribute.remote_port] = lambda: remote_port
+
+        return attributes
+
+    @property
+    @abstractmethod
+    def _raw_socket(self) -> socket.socket:
+        pass
+
+
+class SocketStream(ByteStream, _SocketProvider):
+    """
+    Transports bytes over a socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(cls, sock_or_fd: socket.socket | int) -> SocketStream:
+        """
+        Wrap an existing socket object or file descriptor as a socket stream.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+        The existing socket must already be connected.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a socket stream
+
+        """
+        sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_connected=True)
+        return await get_async_backend().wrap_stream_socket(sock)
+
+
+class UNIXSocketStream(SocketStream):
+    @classmethod
+    async def from_socket(cls, sock_or_fd: socket.socket | int) -> UNIXSocketStream:
+        """
+        Wrap an existing socket object or file descriptor as a UNIX socket stream.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+        The existing socket must already be connected.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a UNIX socket stream
+
+        """
+        sock = _validate_socket(
+            sock_or_fd, socket.SOCK_STREAM, socket.AF_UNIX, require_connected=True
+        )
+        return await get_async_backend().wrap_unix_stream_socket(sock)
+
+    @abstractmethod
+    async def send_fds(self, message: bytes, fds: Collection[int | IOBase]) -> None:
+        """
+        Send file descriptors along with a message to the peer.
+
+        :param message: a non-empty bytestring
+        :param fds: a collection of files (either numeric file descriptors or open file
+            or socket objects)
+        """
+
+    @abstractmethod
+    async def receive_fds(self, msglen: int, maxfds: int) -> tuple[bytes, list[int]]:
+        """
+        Receive file descriptors along with a message from the peer.
+
+        :param msglen: length of the message to expect from the peer
+        :param maxfds: maximum number of file descriptors to expect from the peer
+        :return: a tuple of (message, file descriptors)
+        """
+
+
+class SocketListener(Listener[SocketStream], _SocketProvider):
+    """
+    Listens to incoming socket connections.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(
+        cls,
+        sock_or_fd: socket.socket | int,
+    ) -> SocketListener:
+        """
+        Wrap an existing socket object or file descriptor as a socket listener.
+
+        The newly created listener takes ownership of the socket being passed in.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a socket listener
+
+        """
+        sock = _validate_socket(sock_or_fd, socket.SOCK_STREAM, require_bound=True)
+        return await get_async_backend().wrap_listener_socket(sock)
+
+    @abstractmethod
+    async def accept(self) -> SocketStream:
+        """Accept an incoming connection."""
+
+    async def serve(
+        self,
+        handler: Callable[[SocketStream], Any],
+        task_group: TaskGroup | None = None,
+    ) -> None:
+        from .. import create_task_group
+
+        async with AsyncExitStack() as stack:
+            if task_group is None:
+                task_group = await stack.enter_async_context(create_task_group())
+
+            while True:
+                stream = await self.accept()
+                task_group.start_soon(handler, stream)
+
+
+class UDPSocket(UnreliableObjectStream[UDPPacketType], _SocketProvider):
+    """
+    Represents an unconnected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(cls, sock_or_fd: socket.socket | int) -> UDPSocket:
+        """
+        Wrap an existing socket object or file descriptor as a UDP socket.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+        The existing socket must be bound to a local address.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a UDP socket
+
+        """
+        sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, require_bound=True)
+        return await get_async_backend().wrap_udp_socket(sock)
+
+    async def sendto(self, data: bytes, host: str, port: int) -> None:
+        """
+        Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, (host, port))).
+
+        """
+        return await self.send((data, (host, port)))
+
+
+class ConnectedUDPSocket(UnreliableObjectStream[bytes], _SocketProvider):
+    """
+    Represents an connected UDP socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(cls, sock_or_fd: socket.socket | int) -> ConnectedUDPSocket:
+        """
+        Wrap an existing socket object or file descriptor as a connected UDP socket.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+        The existing socket must already be connected.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a connected UDP socket
+
+        """
+        sock = _validate_socket(
+            sock_or_fd,
+            socket.SOCK_DGRAM,
+            require_connected=True,
+        )
+        return await get_async_backend().wrap_connected_udp_socket(sock)
+
+
+class UNIXDatagramSocket(
+    UnreliableObjectStream[UNIXDatagramPacketType], _SocketProvider
+):
+    """
+    Represents an unconnected Unix datagram socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(
+        cls,
+        sock_or_fd: socket.socket | int,
+    ) -> UNIXDatagramSocket:
+        """
+        Wrap an existing socket object or file descriptor as a UNIX datagram
+        socket.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a UNIX datagram socket
+
+        """
+        sock = _validate_socket(sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX)
+        return await get_async_backend().wrap_unix_datagram_socket(sock)
+
+    async def sendto(self, data: bytes, path: str) -> None:
+        """Alias for :meth:`~.UnreliableObjectSendStream.send` ((data, path))."""
+        return await self.send((data, path))
+
+
+class ConnectedUNIXDatagramSocket(UnreliableObjectStream[bytes], _SocketProvider):
+    """
+    Represents a connected Unix datagram socket.
+
+    Supports all relevant extra attributes from :class:`~SocketAttribute`.
+    """
+
+    @classmethod
+    async def from_socket(
+        cls,
+        sock_or_fd: socket.socket | int,
+    ) -> ConnectedUNIXDatagramSocket:
+        """
+        Wrap an existing socket object or file descriptor as a connected UNIX datagram
+        socket.
+
+        The newly created socket wrapper takes ownership of the socket being passed in.
+        The existing socket must already be connected.
+
+        :param sock_or_fd: a socket object or file descriptor
+        :return: a connected UNIX datagram socket
+
+        """
+        sock = _validate_socket(
+            sock_or_fd, socket.SOCK_DGRAM, socket.AF_UNIX, require_connected=True
+        )
+        return await get_async_backend().wrap_connected_unix_datagram_socket(sock)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_streams.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_streams.py
new file mode 100644
index 0000000000000000000000000000000000000000..daf335dc3235ff8e4d5253610cd5e68de17c3f6d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_streams.py
@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, Generic, TypeAlias, TypeVar
+
+from .._core._exceptions import EndOfStream
+from .._core._typedattr import TypedAttributeProvider
+from ._resources import AsyncResource
+
+if TYPE_CHECKING:
+    from ._tasks import TaskGroup
+
+T_Item = TypeVar("T_Item")
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+
+
+class UnreliableObjectReceiveStream(
+    AsyncResource, TypedAttributeProvider, Generic[T_co]
+):
+    """
+    An interface for receiving objects.
+
+    This interface makes no guarantees that the received messages arrive in the order in
+    which they were sent, or that no messages are missed.
+
+    Asynchronously iterating over objects of this type will yield objects matching the
+    given type parameter.
+    """
+
+    def __aiter__(self) -> UnreliableObjectReceiveStream[T_co]:
+        return self
+
+    async def __anext__(self) -> T_co:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration from None
+
+    @abstractmethod
+    async def receive(self) -> T_co:
+        """
+        Receive the next item.
+
+        :raises ~anyio.ClosedResourceError: if the receive stream has been explicitly
+            closed
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectSendStream(
+    AsyncResource, TypedAttributeProvider, Generic[T_contra]
+):
+    """
+    An interface for sending objects.
+
+    This interface makes no guarantees that the messages sent will reach the
+    recipient(s) in the same order in which they were sent, or at all.
+    """
+
+    @abstractmethod
+    async def send(self, item: T_contra) -> None:
+        """
+        Send an item to the peer(s).
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if the send stream has been explicitly
+            closed
+        :raises ~anyio.BrokenResourceError: if this stream has been rendered unusable
+            due to external causes
+        """
+
+
+class UnreliableObjectStream(
+    UnreliableObjectReceiveStream[T_Item], UnreliableObjectSendStream[T_Item]
+):
+    """
+    A bidirectional message stream which does not guarantee the order or reliability of
+    message delivery.
+    """
+
+
+class ObjectReceiveStream(UnreliableObjectReceiveStream[T_co]):
+    """
+    A receive message stream which guarantees that messages are received in the same
+    order in which they were sent, and that no messages are missed.
+    """
+
+
+class ObjectSendStream(UnreliableObjectSendStream[T_contra]):
+    """
+    A send message stream which guarantees that messages are delivered in the same order
+    in which they were sent, without missing any messages in the middle.
+    """
+
+
+class ObjectStream(
+    ObjectReceiveStream[T_Item],
+    ObjectSendStream[T_Item],
+    UnreliableObjectStream[T_Item],
+):
+    """
+    A bidirectional message stream which guarantees the order and reliability of message
+    delivery.
+    """
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this
+        method. This method is idempotent (does nothing on successive calls).
+        """
+
+
+class ByteReceiveStream(AsyncResource, TypedAttributeProvider):
+    """
+    An interface for receiving bytes from a single peer.
+
+    Iterating this byte stream will yield a byte string of arbitrary length, but no more
+    than 65536 bytes.
+    """
+
+    def __aiter__(self) -> ByteReceiveStream:
+        return self
+
+    async def __anext__(self) -> bytes:
+        try:
+            return await self.receive()
+        except EndOfStream:
+            raise StopAsyncIteration from None
+
+    @abstractmethod
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        """
+        Receive at most ``max_bytes`` bytes from the peer.
+
+        .. note:: Implementers of this interface should not return an empty
+            :class:`bytes` object, and users should ignore them.
+
+        :param max_bytes: maximum number of bytes to receive (must be a positive
+            integer)
+        :return: the received bytes
+        :raises ValueError: if ``max_bytes`` is less than 1
+        :raises ~anyio.EndOfStream: if this stream has been closed from the other end
+        """
+
+
+class ByteSendStream(AsyncResource, TypedAttributeProvider):
+    """An interface for sending bytes to a single peer."""
+
+    @abstractmethod
+    async def send(self, item: bytes) -> None:
+        """
+        Send the given bytes to the peer.
+
+        :param item: the bytes to send
+        """
+
+
+class ByteStream(ByteReceiveStream, ByteSendStream):
+    """A bidirectional byte stream."""
+
+    @abstractmethod
+    async def send_eof(self) -> None:
+        """
+        Send an end-of-file indication to the peer.
+
+        You should not try to send any further data to this stream after calling this
+        method. This method is idempotent (does nothing on successive calls).
+        """
+
+
+#: Type alias for all unreliable bytes-oriented receive streams.
+AnyUnreliableByteReceiveStream: TypeAlias = (
+    UnreliableObjectReceiveStream[bytes] | ByteReceiveStream
+)
+#: Type alias for all unreliable bytes-oriented send streams.
+AnyUnreliableByteSendStream: TypeAlias = (
+    UnreliableObjectSendStream[bytes] | ByteSendStream
+)
+#: Type alias for all unreliable bytes-oriented streams.
+AnyUnreliableByteStream: TypeAlias = UnreliableObjectStream[bytes] | ByteStream
+#: Type alias for all bytes-oriented receive streams.
+AnyByteReceiveStream: TypeAlias = ObjectReceiveStream[bytes] | ByteReceiveStream
+#: Type alias for all bytes-oriented send streams.
+AnyByteSendStream: TypeAlias = ObjectSendStream[bytes] | ByteSendStream
+#: Type alias for all bytes-oriented streams.
+AnyByteStream: TypeAlias = ObjectStream[bytes] | ByteStream
+
+
+class Listener(AsyncResource, TypedAttributeProvider, Generic[T_co]):
+    """An interface for objects that let you accept incoming connections."""
+
+    @abstractmethod
+    async def serve(
+        self, handler: Callable[[T_co], Any], task_group: TaskGroup | None = None
+    ) -> None:
+        """
+        Accept incoming connections as they come in and start tasks to handle them.
+
+        :param handler: a callable that will be used to handle each accepted connection
+        :param task_group: the task group that will be used to start tasks for handling
+            each accepted connection (if omitted, an ad-hoc task group will be created)
+        """
+
+
+class ObjectStreamConnectable(Generic[T_co], metaclass=ABCMeta):
+    @abstractmethod
+    async def connect(self) -> ObjectStream[T_co]:
+        """
+        Connect to the remote endpoint.
+
+        :return: an object stream connected to the remote end
+        :raises ConnectionFailed: if the connection fails
+        """
+
+
+class ByteStreamConnectable(metaclass=ABCMeta):
+    @abstractmethod
+    async def connect(self) -> ByteStream:
+        """
+        Connect to the remote endpoint.
+
+        :return: a bytestream connected to the remote end
+        :raises ConnectionFailed: if the connection fails
+        """
+
+
+#: Type alias for all connectables returning bytestreams or bytes-oriented object streams
+AnyByteStreamConnectable: TypeAlias = (
+    ObjectStreamConnectable[bytes] | ByteStreamConnectable
+)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_subprocesses.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_subprocesses.py
new file mode 100644
index 0000000000000000000000000000000000000000..555f15f10d2b8375a791a620eafd87795d8e9107
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_subprocesses.py
@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from signal import Signals
+from typing import TYPE_CHECKING
+
+from ._resources import AsyncResource
+
+if TYPE_CHECKING:
+    from ._streams import ByteReceiveStream, ByteSendStream
+
+
+class Process(AsyncResource):
+    """An asynchronous version of :class:`subprocess.Popen`."""
+
+    @abstractmethod
+    async def wait(self) -> int:
+        """
+        Wait until the process exits.
+
+        :return: the exit code of the process
+        """
+
+    @abstractmethod
+    def terminate(self) -> None:
+        """
+        Terminates the process, gracefully if possible.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGTERM`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.terminate`
+        """
+
+    @abstractmethod
+    def kill(self) -> None:
+        """
+        Kills the process.
+
+        On Windows, this calls ``TerminateProcess()``.
+        On POSIX systems, this sends ``SIGKILL`` to the process.
+
+        .. seealso:: :meth:`subprocess.Popen.kill`
+        """
+
+    @abstractmethod
+    def send_signal(self, signal: Signals) -> None:
+        """
+        Send a signal to the subprocess.
+
+        .. seealso:: :meth:`subprocess.Popen.send_signal`
+
+        :param signal: the signal number (e.g. :data:`signal.SIGHUP`)
+        """
+
+    @property
+    @abstractmethod
+    def pid(self) -> int:
+        """The process ID of the process."""
+
+    @property
+    @abstractmethod
+    def returncode(self) -> int | None:
+        """
+        The return code of the process. If the process has not yet terminated, this will
+        be ``None``.
+        """
+
+    @property
+    @abstractmethod
+    def stdin(self) -> ByteSendStream | None:
+        """The stream for the standard input of the process."""
+
+    @property
+    @abstractmethod
+    def stdout(self) -> ByteReceiveStream | None:
+        """The stream for the standard output of the process."""
+
+    @property
+    @abstractmethod
+    def stderr(self) -> ByteReceiveStream | None:
+        """The stream for the standard error output of the process."""
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_tasks.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_tasks.py
new file mode 100644
index 0000000000000000000000000000000000000000..0a019e2ed3bd6bc36c97f87f3a8b9eee2ba0f657
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_tasks.py
@@ -0,0 +1,223 @@
+from __future__ import annotations
+
+import sys
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable, Coroutine
+from contextvars import Context
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Literal, Protocol, final, overload
+
+if sys.version_info >= (3, 13):
+    from typing import TypeVar
+else:
+    from typing_extensions import TypeVar
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if TYPE_CHECKING:
+    from .._core._tasks import CancelScope, TaskHandle
+
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True, default=None)
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+def get_coro_name(coro: Coroutine[Any, Any, object], override: object = None) -> str:
+    if override is not None:
+        return str(override)
+
+    try:
+        cr_frame = coro.cr_frame  # type: ignore[attr-defined]
+        module = cr_frame.f_globals["__name__"]
+    except (AttributeError, KeyError):
+        module = None
+
+    qualname = getattr(coro, "__qualname__", None)
+    return ".".join([x for x in (module, qualname) if x])
+
+
+def get_callable_name(func: Callable, override: object = None) -> str:
+    if override is not None:
+        return str(override)
+
+    module = getattr(func, "__module__", None)
+    qualname = getattr(func, "__qualname__", None)
+    return ".".join([x for x in (module, qualname) if x])
+
+
+def call_for_coroutine(
+    func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+    args: tuple[Unpack[PosArgsT]],
+    **kwargs: Any,
+) -> Coroutine[Any, Any, T_co]:
+    """
+    Call the given function with the given positional and keyword arguments.
+
+    :return: the resulting coroutine
+    :raises TypeError: if the return value was not a coroutine object
+
+    """
+    coro = func(*args, **kwargs)
+    if not isinstance(coro, Coroutine):
+        prefix = f"{func.__module__}." if hasattr(func, "__module__") else ""
+        raise TypeError(
+            f"Expected {prefix}{func.__qualname__}() to return a coroutine, but "
+            f"the return value ({coro!r}) is not a coroutine object"
+        )
+
+    return coro
+
+
+class TaskStatus(Protocol[T_contra]):
+    @overload
+    def started(self: TaskStatus[None]) -> None: ...
+
+    @overload
+    def started(self, value: T_contra) -> None: ...
+
+    def started(self, value: T_contra | None = None) -> None:
+        """
+        Signal that the task has started.
+
+        :param value: object passed back to the starter of the task
+        """
+
+
+class TaskGroup(metaclass=ABCMeta):
+    """
+    Groups several asynchronous tasks together.
+
+    :ivar cancel_scope: the cancel scope inherited by all child tasks
+    :vartype cancel_scope: CancelScope
+
+    .. note:: On asyncio, support for eager task factories is considered to be
+        **experimental**. In particular, they don't follow the usual semantics of new
+        tasks being scheduled on the next iteration of the event loop, and may thus
+        cause unexpected behavior in code that wasn't written with such semantics in
+        mind.
+    """
+
+    cancel_scope: CancelScope
+
+    def cancel(self, reason: str | None = None) -> None:
+        """
+        Cancel this task group's cancel scope immediately.
+
+        This is a shortcut for calling ``.cancel_scope.cancel()`` on the task group.
+
+        :param reason: a message describing the reason for the cancellation
+
+        .. versionadded:: 4.14.0
+
+        """
+        self.cancel_scope.cancel(reason)
+
+    @abstractmethod
+    def create_task(
+        self,
+        coro: Coroutine[Any, Any, T_co],
+        *,
+        name: object = None,
+        context: Context | None = None,
+    ) -> TaskHandle[T_co]:
+        """
+        Create a new task from a coroutine object and schedule it to run.
+
+        :param coro: a coroutine object
+        :param name: optional name to give the task
+        :param context: optional context to run the task in
+        :return: a task handle
+
+        .. versionadded:: 4.14.0
+        """
+
+    @final
+    def start_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> TaskHandle[T_co]:
+        """
+        Start a new task in this task group.
+
+        :param func: a coroutine function
+        :param args: positional arguments to call the function with
+        :param name: name of the task, for the purposes of introspection and debugging
+        :return: a task handle
+
+        .. versionadded:: 3.0
+        .. versionchanged:: 4.14.0
+            This method now returns a task handle.
+
+        """
+        final_name = get_callable_name(func, name)
+        return self.create_task(call_for_coroutine(func, args), name=final_name)
+
+    @overload
+    async def start(
+        self,
+        func: Callable[..., Coroutine[Any, Any, T_co]],
+        *args: object,
+        name: object = None,
+        return_handle: Literal[False] = ...,
+    ) -> Any: ...
+
+    @overload
+    async def start(
+        self,
+        func: Callable[..., Coroutine[Any, Any, T_co]],
+        *args: object,
+        name: object = None,
+        return_handle: Literal[True],
+    ) -> TaskHandle[T_co, Any]: ...
+
+    @abstractmethod
+    async def start(
+        self,
+        func: Callable[..., Coroutine[Any, Any, T_co]],
+        *args: object,
+        name: object = None,
+        return_handle: Literal[False, True] = False,
+    ) -> Any:
+        """
+        Start a new task and wait until it signals for readiness.
+
+        The target callable must accept a keyword argument ``task_status`` (of type
+        :class:`TaskStatus`). Awaiting on this method will return whatever was passed to
+        ``task_status.started()`` (``None`` by default).
+
+        .. note:: The :class:`TaskStatus` class is generic, and the type argument should
+            indicate the type of the value that will be passed to
+            ``task_status.started()``.
+
+        :param func: a coroutine function that accepts the ``task_status`` keyword
+            argument
+        :param args: positional arguments to call the function with
+        :param name: an optional name for the task, for introspection and debugging
+        :param return_handle: if ``True``, return a :class:`TaskHandle` which also
+            contains the start value in ``start_value``
+        :return: the value passed to ``task_status.started()``
+        :raises RuntimeError: if the task finishes without calling
+            ``task_status.started()``
+
+        .. seealso:: :ref:`start_initialize`
+
+        .. versionadded:: 3.0
+        """
+
+    @abstractmethod
+    async def __aenter__(self) -> TaskGroup:
+        """Enter the task group context and allow starting new tasks."""
+
+    @abstractmethod
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        """Exit the task group context waiting for all tasks to finish."""
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_testing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..b18d8357e7a71d228877584e98b1286d273928f4
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/abc/_testing.py
@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import sys
+import types
+from abc import ABCMeta, abstractmethod
+from collections.abc import AsyncGenerator, Callable, Coroutine, Iterable
+from typing import Any, TypeVar
+
+if sys.version_info >= (3, 11):
+    from typing import Self
+else:
+    from typing_extensions import Self
+
+_T = TypeVar("_T")
+
+
+class TestRunner(metaclass=ABCMeta):
+    """
+    Encapsulates a running event loop. Every call made through this object will use the
+    same event loop.
+    """
+
+    def __enter__(self) -> Self:
+        return self
+
+    @abstractmethod
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: types.TracebackType | None,
+    ) -> bool | None: ...
+
+    @abstractmethod
+    def run_asyncgen_fixture(
+        self,
+        fixture_func: Callable[..., AsyncGenerator[_T, Any]],
+        kwargs: dict[str, Any],
+    ) -> Iterable[_T]:
+        """
+        Run an async generator fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: an iterator yielding the value yielded from the async generator
+        """
+
+    @abstractmethod
+    def run_fixture(
+        self,
+        fixture_func: Callable[..., Coroutine[Any, Any, _T]],
+        kwargs: dict[str, Any],
+    ) -> _T:
+        """
+        Run an async fixture.
+
+        :param fixture_func: the fixture function
+        :param kwargs: keyword arguments to call the fixture function with
+        :return: the return value of the fixture function
+        """
+
+    @abstractmethod
+    def run_test(
+        self, test_func: Callable[..., Coroutine[Any, Any, Any]], kwargs: dict[str, Any]
+    ) -> None:
+        """
+        Run an async test function.
+
+        :param test_func: the test function
+        :param kwargs: keyword arguments to call the test function with
+        """
+
+    @abstractmethod
+    def is_running(self) -> bool:
+        """
+        Check if the test runner is running.
+
+        :return: ``True`` if the coroutine is currently being run, ``False`` otherwise.
+        """
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/from_thread.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/from_thread.py
new file mode 100644
index 0000000000000000000000000000000000000000..f163d818b030f752350558e805988bf8c558b262
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/from_thread.py
@@ -0,0 +1,588 @@
+from __future__ import annotations
+
+__all__ = (
+    "BlockingPortal",
+    "BlockingPortalProvider",
+    "check_cancelled",
+    "run",
+    "run_sync",
+    "start_blocking_portal",
+)
+
+import sys
+from collections.abc import Awaitable, Callable, Coroutine, Generator
+from concurrent.futures import Future
+from contextlib import (
+    AbstractAsyncContextManager,
+    AbstractContextManager,
+    contextmanager,
+)
+from contextvars import Context
+from dataclasses import dataclass, field
+from functools import partial
+from inspect import isawaitable
+from threading import Lock, Thread, current_thread, get_ident
+from types import TracebackType
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    cast,
+    overload,
+)
+
+from ._core._eventloop import (
+    get_cancelled_exc_class,
+    threadlocals,
+)
+from ._core._eventloop import run as run_eventloop
+from ._core._exceptions import NoEventLoopError
+from ._core._synchronization import Event
+from ._core._tasks import CancelScope, create_task_group
+from .abc._tasks import TaskStatus
+from .lowlevel import EventLoopToken, current_token
+
+if sys.version_info >= (3, 11):
+    from typing import Self, TypeVarTuple, Unpack
+else:
+    from typing_extensions import Self, TypeVarTuple, Unpack
+
+T_Retval = TypeVar("T_Retval")
+T_co = TypeVar("T_co", covariant=True)
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+def _token_or_error(token: EventLoopToken | None) -> EventLoopToken:
+    if token is not None:
+        return token
+
+    try:
+        return threadlocals.current_token
+    except AttributeError:
+        raise NoEventLoopError(
+            "Not running inside an AnyIO worker thread, and no event loop token was "
+            "provided"
+        ) from None
+
+
+def run(
+    func: Callable[[Unpack[PosArgsT]], Coroutine[Any, Any, T_co]],
+    *args: Unpack[PosArgsT],
+    token: EventLoopToken | None = None,
+) -> T_co:
+    """
+    Call a coroutine function from a worker thread.
+
+    :param func: a coroutine function
+    :param args: positional arguments for the callable
+    :param token: an event loop token to use to get back to the event loop thread
+        (required if calling this function from outside an AnyIO worker thread)
+    :return: the return value of the coroutine function
+    :raises MissingTokenError: if no token was provided and called from outside an
+        AnyIO worker thread
+    :raises RunFinishedError: if the event loop tied to ``token`` is no longer running
+
+    .. versionchanged:: 4.11.0
+        Added the ``token`` parameter.
+
+    """
+    explicit_token = token is not None
+    token = _token_or_error(token)
+    return token.backend_class.run_async_from_thread(
+        func, args, token=token.native_token if explicit_token else None
+    )
+
+
+def run_sync(
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
+    token: EventLoopToken | None = None,
+) -> T_Retval:
+    """
+    Call a function in the event loop thread from a worker thread.
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :param token: an event loop token to use to get back to the event loop thread
+        (required if calling this function from outside an AnyIO worker thread)
+    :return: the return value of the callable
+    :raises MissingTokenError: if no token was provided and called from outside an
+        AnyIO worker thread
+    :raises RunFinishedError: if the event loop tied to ``token`` is no longer running
+
+    .. versionchanged:: 4.11.0
+        Added the ``token`` parameter.
+
+    """
+    explicit_token = token is not None
+    token = _token_or_error(token)
+    return token.backend_class.run_sync_from_thread(
+        func, args, token=token.native_token if explicit_token else None
+    )
+
+
+class _BlockingAsyncContextManager(AbstractContextManager, Generic[T_co]):
+    _enter_future: Future[T_co]
+    _exit_future: Future[bool | None]
+    _exit_event: Event
+    _exit_exc_info: tuple[
+        type[BaseException] | None, BaseException | None, TracebackType | None
+    ] = (None, None, None)
+
+    def __init__(
+        self, async_cm: AbstractAsyncContextManager[T_co], portal: BlockingPortal
+    ):
+        self._async_cm = async_cm
+        self._portal = portal
+
+    async def run_async_cm(self) -> bool | None:
+        try:
+            self._exit_event = Event()
+            value = await self._async_cm.__aenter__()
+        except BaseException as exc:
+            self._enter_future.set_exception(exc)
+            raise
+        else:
+            self._enter_future.set_result(value)
+
+        try:
+            # Wait for the sync context manager to exit.
+            # This next statement can raise `get_cancelled_exc_class()` if
+            # something went wrong in a task group in this async context
+            # manager.
+            await self._exit_event.wait()
+        finally:
+            # In case of cancellation, it could be that we end up here before
+            # `_BlockingAsyncContextManager.__exit__` is called, and an
+            # `_exit_exc_info` has been set.
+            result = await self._async_cm.__aexit__(*self._exit_exc_info)
+
+        return result
+
+    def __enter__(self) -> T_co:
+        self._enter_future = Future()
+        self._exit_future = self._portal.start_task_soon(self.run_async_cm)
+        return self._enter_future.result()
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+        /,
+    ) -> bool | None:
+        self._exit_exc_info = exc_type, exc_value, traceback
+        self._portal.call(self._exit_event.set)
+        return self._exit_future.result()
+
+
+class _BlockingPortalTaskStatus(TaskStatus):
+    def __init__(self, future: Future):
+        self._future = future
+
+    def started(self, value: object = None) -> None:
+        self._future.set_result(value)
+
+
+class BlockingPortal:
+    """
+    An object that lets external threads run code in an asynchronous event loop.
+
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+    """
+
+    def __init__(self) -> None:
+        self._token = current_token()
+        self._event_loop_thread_id: int | None = get_ident()
+        self._stop_event = Event()
+        self._task_group = create_task_group()
+
+    async def __aenter__(self) -> Self:
+        await self._task_group.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool:
+        await self.stop()
+        return await self._task_group.__aexit__(exc_type, exc_val, exc_tb)
+
+    def _check_running(self) -> None:
+        if self._event_loop_thread_id is None:
+            raise RuntimeError("This portal is not running")
+        if self._event_loop_thread_id == get_ident():
+            raise RuntimeError(
+                "This method cannot be called from the event loop thread"
+            )
+
+    async def sleep_until_stopped(self) -> None:
+        """Sleep until :meth:`stop` is called."""
+        await self._stop_event.wait()
+
+    async def stop(self, cancel_remaining: bool = False) -> None:
+        """
+        Signal the portal to shut down.
+
+        This marks the portal as no longer accepting new calls and exits from
+        :meth:`sleep_until_stopped`.
+
+        :param cancel_remaining: ``True`` to cancel all the remaining tasks, ``False``
+            to let them finish before returning
+
+        """
+        self._event_loop_thread_id = None
+        self._stop_event.set()
+        if cancel_remaining:
+            self._task_group.cancel_scope.cancel("the blocking portal is shutting down")
+
+    async def _call_func(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        future: Future[T_Retval],
+    ) -> None:
+        event_loop_thread_id = self._event_loop_thread_id
+
+        def callback(f: Future[T_Retval]) -> None:
+            if f.cancelled():
+                if event_loop_thread_id == get_ident():
+                    scope.cancel("the future was cancelled")
+                elif event_loop_thread_id is not None:
+                    run_sync(
+                        scope.cancel, "the future was cancelled", token=self._token
+                    )
+
+        try:
+            retval_or_awaitable = func(*args, **kwargs)
+            if isawaitable(retval_or_awaitable):
+                with CancelScope() as scope:
+                    future.add_done_callback(callback)
+                    retval = await retval_or_awaitable
+            else:
+                retval = retval_or_awaitable
+        except get_cancelled_exc_class():
+            future.cancel()
+            future.set_running_or_notify_cancel()
+        except BaseException as exc:
+            if not future.cancelled():
+                future.set_exception(exc)
+
+            # Let base exceptions fall through
+            if not isinstance(exc, Exception):
+                raise
+        else:
+            if not future.cancelled():
+                future.set_result(retval)
+        finally:
+            scope = None  # type: ignore[assignment]
+
+    def _spawn_task_from_thread(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        args: tuple[Unpack[PosArgsT]],
+        kwargs: dict[str, Any],
+        name: object,
+        future: Future[T_Retval],
+    ) -> None:
+        """
+        Spawn a new task using the given callable.
+
+        :param func: a callable
+        :param args: positional arguments to be passed to the callable
+        :param kwargs: keyword arguments to be passed to the callable
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :param future: a future that will resolve to the return value of the callable,
+            or the exception raised during its execution
+
+        """
+        run_sync(
+            partial(self._task_group.start_soon, name=name),
+            self._call_func,
+            func,
+            args,
+            kwargs,
+            future,
+            token=self._token,
+        )
+
+    @overload
+    def call(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        *args: Unpack[PosArgsT],
+    ) -> T_Retval: ...
+
+    @overload
+    def call(
+        self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT]
+    ) -> T_Retval: ...
+
+    def call(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        *args: Unpack[PosArgsT],
+    ) -> T_Retval:
+        """
+        Call the given function in the event loop thread.
+
+        If the callable returns a coroutine object, it is awaited on.
+
+        :param func: any callable
+        :raises RuntimeError: if the portal is not running or if this method is called
+            from within the event loop thread
+
+        """
+        return cast(T_Retval, self.start_task_soon(func, *args).result())
+
+    @overload
+    def start_task_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval]],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]: ...
+
+    @overload
+    def start_task_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], T_Retval],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]: ...
+
+    def start_task_soon(
+        self,
+        func: Callable[[Unpack[PosArgsT]], Awaitable[T_Retval] | T_Retval],
+        *args: Unpack[PosArgsT],
+        name: object = None,
+    ) -> Future[T_Retval]:
+        """
+        Start a task in the portal's task group.
+
+        The task will be run inside a cancel scope which can be cancelled by cancelling
+        the returned future.
+
+        :param func: the target function
+        :param args: positional arguments passed to ``func``
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :return: a future that resolves with the return value of the callable if the
+            task completes successfully, or with the exception raised in the task
+        :raises RuntimeError: if the portal is not running or if this method is called
+            from within the event loop thread
+        :rtype: concurrent.futures.Future[T_Retval]
+
+        .. versionadded:: 3.0
+
+        """
+        self._check_running()
+        f: Future[T_Retval] = Future()
+        self._spawn_task_from_thread(func, args, {}, name, f)
+        return f
+
+    def start_task(
+        self,
+        func: Callable[..., Awaitable[T_Retval]],
+        *args: object,
+        name: object = None,
+    ) -> tuple[Future[T_Retval], Any]:
+        """
+        Start a task in the portal's task group and wait until it signals for readiness.
+
+        This method works the same way as :meth:`.abc.TaskGroup.start`.
+
+        :param func: the target function
+        :param args: positional arguments passed to ``func``
+        :param name: name of the task (will be coerced to a string if not ``None``)
+        :return: a tuple of (future, task_status_value) where the ``task_status_value``
+            is the value passed to ``task_status.started()`` from within the target
+            function
+        :rtype: tuple[concurrent.futures.Future[T_Retval], Any]
+
+        .. versionadded:: 3.0
+
+        """
+
+        def task_done(future: Future[T_Retval]) -> None:
+            if not task_status_future.done():
+                if future.cancelled():
+                    task_status_future.cancel()
+                elif future.exception():
+                    task_status_future.set_exception(future.exception())
+                else:
+                    exc = RuntimeError(
+                        "Task exited without calling task_status.started()"
+                    )
+                    task_status_future.set_exception(exc)
+
+        self._check_running()
+        task_status_future: Future = Future()
+        task_status = _BlockingPortalTaskStatus(task_status_future)
+        f: Future = Future()
+        f.add_done_callback(task_done)
+        self._spawn_task_from_thread(func, args, {"task_status": task_status}, name, f)
+        return f, task_status_future.result()
+
+    def wrap_async_context_manager(
+        self, cm: AbstractAsyncContextManager[T_co]
+    ) -> AbstractContextManager[T_co]:
+        """
+        Wrap an async context manager as a synchronous context manager via this portal.
+
+        Spawns a task that will call both ``__aenter__()`` and ``__aexit__()``, stopping
+        in the middle until the synchronous context manager exits.
+
+        :param cm: an asynchronous context manager
+        :return: a synchronous context manager
+
+        .. versionadded:: 2.1
+
+        """
+        return _BlockingAsyncContextManager(cm, self)
+
+
+@dataclass
+class BlockingPortalProvider:
+    """
+    A manager for a blocking portal. Used as a context manager. The first thread to
+    enter this context manager causes a blocking portal to be started with the specific
+    parameters, and the last thread to exit causes the portal to be shut down. Thus,
+    there will be exactly one blocking portal running in this context as long as at
+    least one thread has entered this context manager.
+
+    The parameters are the same as for :func:`~anyio.run`.
+
+    :param backend: name of the backend
+    :param backend_options: backend options
+
+    .. versionadded:: 4.4
+    """
+
+    backend: str = "asyncio"
+    backend_options: dict[str, Any] | None = None
+    _lock: Lock = field(init=False, default_factory=Lock)
+    _leases: int = field(init=False, default=0)
+    _portal: BlockingPortal = field(init=False)
+    _portal_cm: AbstractContextManager[BlockingPortal] | None = field(
+        init=False, default=None
+    )
+
+    def __enter__(self) -> BlockingPortal:
+        with self._lock:
+            if self._portal_cm is None:
+                self._portal_cm = start_blocking_portal(
+                    self.backend, self.backend_options
+                )
+                self._portal = self._portal_cm.__enter__()
+
+            self._leases += 1
+            return self._portal
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        portal_cm: AbstractContextManager[BlockingPortal] | None = None
+        with self._lock:
+            assert self._portal_cm
+            assert self._leases > 0
+            self._leases -= 1
+            if not self._leases:
+                portal_cm = self._portal_cm
+                self._portal_cm = None
+                del self._portal
+
+        if portal_cm:
+            portal_cm.__exit__(None, None, None)
+
+
+@contextmanager
+def start_blocking_portal(
+    backend: str = "asyncio",
+    backend_options: dict[str, Any] | None = None,
+    *,
+    name: str | None = None,
+) -> Generator[BlockingPortal, Any, None]:
+    """
+    Start a new event loop in a new thread and run a blocking portal in its main task.
+
+    The parameters are the same as for :func:`~anyio.run`.
+
+    :param backend: name of the backend
+    :param backend_options: backend options
+    :param name: name of the thread
+    :return: a context manager that yields a blocking portal
+
+    .. versionchanged:: 3.0
+        Usage as a context manager is now required.
+
+    """
+
+    async def run_portal() -> None:
+        async with BlockingPortal() as portal_:
+            if name is None:
+                current_thread().name = f"{backend}-portal-{id(portal_):x}"
+
+            future.set_result(portal_)
+            await portal_.sleep_until_stopped()
+
+    def run_blocking_portal() -> None:
+        if future.set_running_or_notify_cancel():
+            try:
+                run_eventloop(
+                    run_portal, backend=backend, backend_options=backend_options
+                )
+            except BaseException as exc:
+                if not future.done():
+                    future.set_exception(exc)
+
+    future: Future[BlockingPortal] = Future()
+    kwargs: dict[str, Any] = {}
+    if sys.version_info >= (3, 14):
+        kwargs["context"] = Context()
+
+    thread = Thread(target=run_blocking_portal, daemon=True, name=name, **kwargs)
+    thread.start()
+    try:
+        cancel_remaining_tasks = False
+        portal = future.result()
+        try:
+            yield portal
+        except BaseException:
+            cancel_remaining_tasks = True
+            raise
+        finally:
+            try:
+                portal.call(portal.stop, cancel_remaining_tasks)
+            except RuntimeError:
+                pass
+    finally:
+        thread.join()
+
+
+def check_cancelled() -> None:
+    """
+    Check if the cancel scope of the host task's running the current worker thread has
+    been cancelled.
+
+    If the host task's current cancel scope has indeed been cancelled, the
+    backend-specific cancellation exception will be raised.
+
+    :raises RuntimeError: if the current thread was not spawned by
+        :func:`.to_thread.run_sync`
+
+    """
+    try:
+        token: EventLoopToken = threadlocals.current_token
+    except AttributeError:
+        raise NoEventLoopError(
+            "This function can only be called inside an AnyIO worker thread"
+        ) from None
+
+    token.backend_class.check_cancelled()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/functools.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/functools.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0bdfb4585efc4e4799388547668fba86fb5c687
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/functools.py
@@ -0,0 +1,400 @@
+from __future__ import annotations
+
+__all__ = (
+    "AsyncCacheInfo",
+    "AsyncCacheParameters",
+    "AsyncLRUCacheWrapper",
+    "cache",
+    "lru_cache",
+    "reduce",
+)
+
+import functools
+from collections import OrderedDict
+from collections.abc import (
+    AsyncIterable,
+    Awaitable,
+    Callable,
+    Coroutine,
+    Hashable,
+    Iterable,
+)
+from functools import update_wrapper
+from inspect import iscoroutinefunction
+from typing import (
+    Any,
+    Generic,
+    NamedTuple,
+    ParamSpec,
+    TypedDict,
+    TypeVar,
+    cast,
+    final,
+    overload,
+)
+from weakref import WeakKeyDictionary
+
+from ._core._eventloop import current_time
+from ._core._synchronization import Lock
+from .lowlevel import RunVar, checkpoint
+
+T = TypeVar("T")
+S = TypeVar("S")
+P = ParamSpec("P")
+lru_cache_items: RunVar[
+    WeakKeyDictionary[
+        AsyncLRUCacheWrapper[Any, Any],
+        OrderedDict[
+            Hashable,
+            tuple[_InitialMissingType, Lock, float | None]
+            | tuple[Any, None, float | None],
+        ],
+    ]
+] = RunVar("lru_cache_items")
+
+
+class _InitialMissingType:
+    pass
+
+
+initial_missing: _InitialMissingType = _InitialMissingType()
+
+
+class AsyncCacheInfo(NamedTuple):
+    hits: int
+    misses: int
+    maxsize: int | None
+    currsize: int
+    ttl: int | None
+
+
+class AsyncCacheParameters(TypedDict):
+    maxsize: int | None
+    typed: bool
+    always_checkpoint: bool
+    ttl: int | None
+
+
+class _LRUMethodWrapper(Generic[T]):
+    def __init__(self, wrapper: AsyncLRUCacheWrapper[..., T], instance: object):
+        self.__wrapper = wrapper
+        self.__instance = instance
+
+    def cache_info(self) -> AsyncCacheInfo:
+        return self.__wrapper.cache_info()
+
+    def cache_parameters(self) -> AsyncCacheParameters:
+        return self.__wrapper.cache_parameters()
+
+    def cache_clear(self) -> None:
+        self.__wrapper.cache_clear()
+
+    async def __call__(self, *args: Any, **kwargs: Any) -> T:
+        if self.__instance is None:
+            return await self.__wrapper(*args, **kwargs)
+
+        return await self.__wrapper(self.__instance, *args, **kwargs)
+
+
+@final
+class AsyncLRUCacheWrapper(Generic[P, T]):
+    def __init__(
+        self,
+        func: Callable[P, Awaitable[T]],
+        maxsize: int | None,
+        typed: bool,
+        always_checkpoint: bool,
+        ttl: int | None,
+    ):
+        self.__wrapped__ = func
+        self._hits: int = 0
+        self._misses: int = 0
+        self._maxsize = max(maxsize, 0) if maxsize is not None else None
+        self._currsize: int = 0
+        self._typed = typed
+        self._always_checkpoint = always_checkpoint
+        self._ttl = ttl
+        update_wrapper(self, func)
+
+    def cache_info(self) -> AsyncCacheInfo:
+        return AsyncCacheInfo(
+            self._hits, self._misses, self._maxsize, self._currsize, self._ttl
+        )
+
+    def cache_parameters(self) -> AsyncCacheParameters:
+        return {
+            "maxsize": self._maxsize,
+            "typed": self._typed,
+            "always_checkpoint": self._always_checkpoint,
+            "ttl": self._ttl,
+        }
+
+    def cache_clear(self) -> None:
+        if cache := lru_cache_items.get(None):
+            cache.pop(self, None)
+            self._hits = self._misses = self._currsize = 0
+
+    async def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        # Easy case first: if maxsize == 0, no caching is done
+        if self._maxsize == 0:
+            value = await self.__wrapped__(*args, **kwargs)
+            self._misses += 1
+            return value
+
+        # The key is constructed as a flat tuple to avoid memory overhead
+        key: tuple[Any, ...] = args
+        if kwargs:
+            # initial_missing is used as a separator
+            key += (initial_missing,) + sum(kwargs.items(), ())
+
+        if self._typed:
+            key += tuple(type(arg) for arg in args)
+            if kwargs:
+                key += (initial_missing,) + tuple(type(val) for val in kwargs.values())
+
+        try:
+            cache = lru_cache_items.get()
+        except LookupError:
+            cache = WeakKeyDictionary()
+            lru_cache_items.set(cache)
+
+        try:
+            cache_entry = cache[self]
+        except KeyError:
+            cache_entry = cache[self] = OrderedDict()
+
+        cached_value: T | _InitialMissingType
+        try:
+            cached_value, lock, expires_at = cache_entry[key]
+        except KeyError:
+            # We're the first task to call this function
+            cached_value, lock, expires_at = (
+                initial_missing,
+                Lock(fast_acquire=not self._always_checkpoint),
+                None,
+            )
+            cache_entry[key] = cached_value, lock, expires_at
+
+        if lock is None:
+            if expires_at is not None and current_time() >= expires_at:
+                self._currsize -= 1
+                cached_value, lock, expires_at = (
+                    initial_missing,
+                    Lock(fast_acquire=not self._always_checkpoint),
+                    None,
+                )
+                cache_entry[key] = cached_value, lock, expires_at
+            else:
+                # The value was already cached
+                self._hits += 1
+                cache_entry.move_to_end(key)
+                if self._always_checkpoint:
+                    await checkpoint()
+
+                return cast(T, cached_value)
+
+        async with lock:
+            # Check if another task filled the cache while we acquired the lock
+            if (cached_value := cache_entry[key][0]) is initial_missing:
+                self._misses += 1
+                if self._maxsize is not None and self._currsize >= self._maxsize:
+                    cache_entry.popitem(last=False)
+                else:
+                    self._currsize += 1
+
+                value = await self.__wrapped__(*args, **kwargs)
+                expires_at = (
+                    current_time() + self._ttl if self._ttl is not None else None
+                )
+                cache_entry[key] = value, None, expires_at
+            else:
+                # Another task filled the cache while we were waiting for the lock
+                self._hits += 1
+                cache_entry.move_to_end(key)
+                value = cast(T, cached_value)
+
+        return value
+
+    def __get__(
+        self, instance: object, owner: type | None = None
+    ) -> _LRUMethodWrapper[T]:
+        wrapper = _LRUMethodWrapper(self, instance)
+        update_wrapper(wrapper, self.__wrapped__)
+        return wrapper
+
+
+class _LRUCacheWrapper:
+    def __init__(
+        self, maxsize: int | None, typed: bool, always_checkpoint: bool, ttl: int | None
+    ):
+        self._maxsize = maxsize
+        self._typed = typed
+        self._always_checkpoint = always_checkpoint
+        self._ttl = ttl
+
+    @overload
+    def __call__(  # type: ignore[overload-overlap]
+        self, func: Callable[P, Coroutine[Any, Any, T]], /
+    ) -> AsyncLRUCacheWrapper[P, T]: ...
+
+    @overload
+    def __call__(
+        self, func: Callable[..., T], /
+    ) -> functools._lru_cache_wrapper[T]: ...
+
+    def __call__(
+        self, f: Callable[P, Coroutine[Any, Any, T]] | Callable[..., T], /
+    ) -> AsyncLRUCacheWrapper[P, T] | functools._lru_cache_wrapper[T]:
+        if iscoroutinefunction(f):
+            return AsyncLRUCacheWrapper(
+                f, self._maxsize, self._typed, self._always_checkpoint, self._ttl
+            )
+
+        return functools.lru_cache(maxsize=self._maxsize, typed=self._typed)(f)  # type: ignore[arg-type]
+
+
+@overload
+def cache(  # type: ignore[overload-overlap]
+    func: Callable[P, Coroutine[Any, Any, T]], /
+) -> AsyncLRUCacheWrapper[P, T]: ...
+
+
+@overload
+def cache(func: Callable[..., T], /) -> functools._lru_cache_wrapper[T]: ...
+
+
+def cache(func: Callable[..., Any] | Callable[P, Coroutine[Any, Any, Any]], /) -> Any:
+    """
+    A convenient shortcut for :func:`lru_cache` with ``maxsize=None``.
+
+    This is the asynchronous equivalent to :func:`functools.cache`.
+
+    """
+    return lru_cache(maxsize=None)(func)
+
+
+@overload
+def lru_cache(
+    *,
+    maxsize: int | None = ...,
+    typed: bool = ...,
+    always_checkpoint: bool = ...,
+    ttl: int | None = ...,
+) -> _LRUCacheWrapper: ...
+
+
+@overload
+def lru_cache(  # type: ignore[overload-overlap]
+    func: Callable[P, Coroutine[Any, Any, T]], /
+) -> AsyncLRUCacheWrapper[P, T]: ...
+
+
+@overload
+def lru_cache(func: Callable[..., T], /) -> functools._lru_cache_wrapper[T]: ...
+
+
+def lru_cache(
+    func: Callable[..., Coroutine[Any, Any, Any]] | Callable[..., Any] | None = None,
+    /,
+    *,
+    maxsize: int | None = 128,
+    typed: bool = False,
+    always_checkpoint: bool = False,
+    ttl: int | None = None,
+) -> Any:
+    """
+    An asynchronous version of :func:`functools.lru_cache`.
+
+    If a synchronous function is passed, the standard library
+    :func:`functools.lru_cache` is applied instead.
+
+    :param always_checkpoint: if ``True``, every call to the cached function will be
+        guaranteed to yield control to the event loop at least once
+    :param ttl: time in seconds after which to invalidate cache entries
+
+    .. note:: Caches and locks are managed on a per-event loop basis.
+
+    """
+    if func is None:
+        return _LRUCacheWrapper(maxsize, typed, always_checkpoint, ttl)
+
+    if not callable(func):
+        raise TypeError("the first argument must be callable")
+
+    return _LRUCacheWrapper(maxsize, typed, always_checkpoint, ttl)(func)
+
+
+@overload
+async def reduce(
+    function: Callable[[T, S], Awaitable[T]],
+    iterable: Iterable[S] | AsyncIterable[S],
+    /,
+    initial: T,
+) -> T: ...
+
+
+@overload
+async def reduce(
+    function: Callable[[T, T], Awaitable[T]],
+    iterable: Iterable[T] | AsyncIterable[T],
+    /,
+) -> T: ...
+
+
+async def reduce(  # type: ignore[misc]
+    function: Callable[[T, T], Awaitable[T]] | Callable[[T, S], Awaitable[T]],
+    iterable: Iterable[T] | Iterable[S] | AsyncIterable[T] | AsyncIterable[S],
+    /,
+    initial: T | _InitialMissingType = initial_missing,
+) -> T:
+    """
+    Asynchronous version of :func:`functools.reduce`.
+
+    :param function: a coroutine function that takes two arguments: the accumulated
+        value and the next element from the iterable
+    :param iterable: an iterable or async iterable
+    :param initial: the initial value (if missing, the first element of the iterable is
+        used as the initial value)
+
+    """
+    element: Any
+    function_called = False
+    if isinstance(iterable, AsyncIterable):
+        async_it = iterable.__aiter__()
+        if initial is initial_missing:
+            try:
+                value = cast(T, await async_it.__anext__())
+            except StopAsyncIteration:
+                raise TypeError(
+                    "reduce() of empty sequence with no initial value"
+                ) from None
+        else:
+            value = cast(T, initial)
+
+        async for element in async_it:
+            value = await function(value, element)
+            function_called = True
+    elif isinstance(iterable, Iterable):
+        it = iter(iterable)
+        if initial is initial_missing:
+            try:
+                value = cast(T, next(it))
+            except StopIteration:
+                raise TypeError(
+                    "reduce() of empty sequence with no initial value"
+                ) from None
+        else:
+            value = cast(T, initial)
+
+        for element in it:
+            value = await function(value, element)
+            function_called = True
+    else:
+        raise TypeError("reduce() argument 2 must be an iterable or async iterable")
+
+    # Make sure there is at least one checkpoint, even if an empty iterable and an
+    # initial value were given
+    if not function_called:
+        await checkpoint()
+
+    return value
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/itertools.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/itertools.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a10cfd3ba01b22f424d18accaf9758233a67cca
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/itertools.py
@@ -0,0 +1,629 @@
+from __future__ import annotations
+
+__all__ = (
+    "Chain",
+    "accumulate",
+    "batched",
+    "combinations",
+    "combinations_with_replacement",
+    "compress",
+    "count",
+    "cycle",
+    "dropwhile",
+    "filterfalse",
+    "groupby",
+    "islice",
+    "pairwise",
+    "permutations",
+    "product",
+    "repeat",
+    "starmap",
+    "takewhile",
+    "tee",
+    "zip_longest",
+)
+
+import itertools
+import operator
+import sys
+from collections.abc import (
+    AsyncGenerator,
+    AsyncIterable,
+    AsyncIterator,
+    Awaitable,
+    Callable,
+    Iterable,
+    Iterator,
+)
+from dataclasses import dataclass, field
+from typing import Any, Generic, TypeVar, cast, overload
+
+from ._core._synchronization import Lock
+from ._core._tasks import CancelScope
+from .lowlevel import cancel_shielded_checkpoint, checkpoint, checkpoint_if_cancelled
+
+if sys.version_info < (3, 15):
+    from typing_extensions import sentinel
+
+T = TypeVar("T")
+R = TypeVar("R")
+_tee_end = sentinel("_tee_end")
+
+
+@dataclass(eq=False)
+class _IterableAsyncIterator(AsyncIterator[T]):
+    iterator: Iterator[T]
+
+    async def __anext__(self) -> T:
+        await checkpoint_if_cancelled()
+        try:
+            result = next(self.iterator)
+        except StopIteration:
+            await cancel_shielded_checkpoint()
+            raise StopAsyncIteration from None
+
+        await cancel_shielded_checkpoint()
+        return result
+
+
+def _iterate(iterable: Iterable[T] | AsyncIterable[T]) -> AsyncIterator[T]:
+    if isinstance(iterable, AsyncIterator):
+        return iterable
+
+    if isinstance(iterable, AsyncIterable):
+        return iterable.__aiter__()
+
+    return _IterableAsyncIterator(iter(iterable))
+
+
+@dataclass(eq=False)
+class _TeeLink(Generic[T]):
+    value: object | None = None
+    next: _TeeLink[T] | None = None
+    filled: bool = False
+
+
+@dataclass(eq=False)
+class _TeeState(Generic[T]):
+    iterator: AsyncIterator[T]
+    lock: Lock = field(default_factory=Lock)
+
+    async def fill(self, link: _TeeLink[T]) -> bool:
+        if link.filled:
+            return False
+
+        async with self.lock:
+            if link.filled:
+                return True
+
+            link.value = await anext(self.iterator, _tee_end)
+            if link.value is not _tee_end:
+                link.next = _TeeLink()
+
+            link.filled = True
+            return True
+
+
+class _TeeAsyncIterator(AsyncIterator[T]):
+    _state: _TeeState[T]
+    _link: _TeeLink[T]
+    _element_yielded: bool
+
+    def __init__(
+        self, iterable: Iterable[T] | AsyncIterable[T] | _TeeAsyncIterator[T]
+    ) -> None:
+        if isinstance(iterable, _TeeAsyncIterator):
+            self._state = iterable._state
+            self._link = iterable._link
+        else:
+            self._state = _TeeState(_iterate(iterable))
+            self._link = _TeeLink()
+
+        self._element_yielded = False
+
+    async def __anext__(self) -> T:
+        had_yieldpoint = await self._state.fill(self._link)
+        if self._link.value is _tee_end:
+            if not self._element_yielded:
+                await checkpoint()
+
+            raise StopAsyncIteration
+
+        if not had_yieldpoint:
+            await checkpoint_if_cancelled()
+
+        self._element_yielded = True
+        value = cast(T, self._link.value)
+        next_link = self._link.next
+        assert next_link is not None
+        self._link = next_link
+        if not had_yieldpoint:
+            await cancel_shielded_checkpoint()
+
+        return value
+
+
+async def _operator_add(x: T, y: T) -> T:
+    return operator.add(x, y)
+
+
+async def accumulate(
+    iterable: Iterable[T] | AsyncIterable[T],
+    function: Callable[[T, T], Awaitable[T]] = _operator_add,
+    *,
+    initial: T | None = None,
+) -> AsyncGenerator[T, None]:
+    iterator = _iterate(iterable)
+    if initial is None:
+        try:
+            total = await anext(iterator)
+        except StopAsyncIteration:
+            await checkpoint()
+            return
+    else:
+        await checkpoint_if_cancelled()
+        total = initial
+        await cancel_shielded_checkpoint()
+
+    yield total
+
+    async for element in iterator:
+        total = await function(total, element)
+        yield total
+
+
+async def batched(
+    iterable: Iterable[T] | AsyncIterable[T], n: int, *, strict: bool = False
+) -> AsyncGenerator[tuple[T, ...], None]:
+    if n < 1:
+        raise ValueError("n must be at least one")
+
+    iterator = _iterate(iterable)
+
+    while True:
+        batch: list[T] = []
+        for _ in range(n):
+            try:
+                batch.append(await anext(iterator))
+            except StopAsyncIteration:
+                if not batch:
+                    await checkpoint()
+                    return
+                if strict:
+                    raise ValueError("batched(): incomplete batch") from None
+
+                yield tuple(batch)
+                return
+
+        yield tuple(batch)
+
+
+class Chain:
+    def __call__(
+        self, *iterables: Iterable[T] | AsyncIterable[T]
+    ) -> AsyncGenerator[T, None]:
+        return self.from_iterable(iterables)
+
+    async def from_iterable(
+        self,
+        iterables: (
+            Iterable[Iterable[T] | AsyncIterable[T]]
+            | AsyncIterable[Iterable[T] | AsyncIterable[T]]
+        ),
+    ) -> AsyncGenerator[T, None]:
+        element_yielded = False
+        outer_iter = _iterate(iterables)
+
+        try:
+            async for iterable in outer_iter:
+                async for element in _iterate(iterable):
+                    element_yielded = True
+                    yield element
+        finally:
+            aclose = getattr(outer_iter, "aclose", None)
+            if aclose is not None:
+                with CancelScope(shield=True):
+                    await aclose()
+
+        if not element_yielded:
+            await checkpoint()
+
+
+chain: Chain = Chain()
+
+
+async def combinations(
+    iterable: Iterable[T] | AsyncIterable[T], r: int
+) -> AsyncGenerator[tuple[T, ...], None]:
+    pool: list[T] = [element async for element in _iterate(iterable)]
+    async for combination in _iterate(itertools.combinations(pool, r)):
+        yield combination
+
+
+async def combinations_with_replacement(
+    iterable: Iterable[T] | AsyncIterable[T], r: int
+) -> AsyncGenerator[tuple[T, ...], None]:
+    pool: list[T] = [element async for element in _iterate(iterable)]
+    async for combination in _iterate(itertools.combinations_with_replacement(pool, r)):
+        yield combination
+
+
+async def compress(
+    data: Iterable[T] | AsyncIterable[T],
+    selectors: Iterable[object] | AsyncIterable[object],
+) -> AsyncGenerator[T, None]:
+    data_iterator = _iterate(data)
+    selector_iterator = _iterate(selectors)
+    element_yielded = False
+
+    while True:
+        try:
+            datum = await anext(data_iterator)
+            selector = await anext(selector_iterator)
+        except StopAsyncIteration:
+            if not element_yielded:
+                await checkpoint()
+
+            return
+
+        if selector:
+            element_yielded = True
+            yield datum
+
+
+async def count(start: int = 0, step: int = 1) -> AsyncGenerator[int, None]:
+    n = start
+    while True:
+        await checkpoint_if_cancelled()
+        value = n
+        n += step
+        await cancel_shielded_checkpoint()
+        yield value
+
+
+async def cycle(
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[T, None]:
+    saved: list[T] = []
+    async for element in _iterate(iterable):
+        saved.append(element)
+        yield element
+
+    if not saved:
+        await checkpoint()
+        return
+
+    while True:
+        for element in saved:
+            await checkpoint()
+            yield element
+
+
+async def dropwhile(
+    predicate: Callable[[T], Awaitable[object]],
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[T, None]:
+    element_yielded = False
+    dropping = True
+
+    async for element in _iterate(iterable):
+        if dropping and await predicate(element):
+            continue
+
+        dropping = False
+        element_yielded = True
+        yield element
+
+    if not element_yielded:
+        await checkpoint()
+
+
+async def filterfalse(
+    predicate: Callable[[T], Awaitable[object]],
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[T, None]:
+    element_yielded = False
+
+    async for element in _iterate(iterable):
+        if not await predicate(element):
+            element_yielded = True
+            yield element
+
+    if not element_yielded:
+        await checkpoint()
+
+
+@overload
+def groupby(
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[tuple[T, list[T]], None]: ...
+
+
+@overload
+def groupby(
+    iterable: Iterable[T] | AsyncIterable[T],
+    key: Callable[[T], Awaitable[R]],
+) -> AsyncGenerator[tuple[R, list[T]], None]: ...
+
+
+async def groupby(
+    iterable: Iterable[T] | AsyncIterable[T],
+    key: Callable[[T], Awaitable[object]] | None = None,
+) -> AsyncGenerator[tuple[object, list[T]], None]:
+    iterator = _iterate(iterable)
+    try:
+        element = await anext(iterator)
+    except StopAsyncIteration:
+        await checkpoint()
+        return
+
+    group_key = element if key is None else await key(element)
+    values = [element]
+
+    async for element in iterator:
+        next_key = element if key is None else await key(element)
+        if next_key != group_key:
+            completed_group = group_key, values
+            group_key = next_key
+            values = [element]
+            yield completed_group
+        else:
+            values.append(element)
+
+    yield group_key, values
+
+
+@overload
+def islice(
+    iterable: Iterable[T] | AsyncIterable[T],
+    stop: int | None,
+    /,
+) -> AsyncGenerator[T, None]: ...
+
+
+@overload
+def islice(
+    iterable: Iterable[T] | AsyncIterable[T],
+    start: int | None,
+    stop: int | None,
+    step: int | None = 1,
+    /,
+) -> AsyncGenerator[T, None]: ...
+
+
+async def islice(
+    iterable: Iterable[T] | AsyncIterable[T],
+    *args: int | None,
+) -> AsyncGenerator[T, None]:
+    if not args:
+        raise TypeError("islice expected at least 2 arguments, got 1")
+    if len(args) > 3:
+        raise TypeError(f"islice expected at most 4 arguments, got {len(args) + 1}")
+
+    slice_args = slice(*args)
+
+    start_message = (
+        "Indices for islice() must be None or an integer: 0 <= x <= sys.maxsize."
+    )
+    stop_message = (
+        "Stop argument for islice() must be None or an integer: 0 <= x <= sys.maxsize."
+    )
+    step_message = "Step for islice() must be a positive integer or None."
+
+    def normalize_index(value: object, message: str) -> int:
+        try:
+            index = operator.index(cast(Any, value))
+        except TypeError:
+            raise ValueError(message) from None
+
+        if index < 0 or index > sys.maxsize:
+            raise ValueError(message)
+
+        return index
+
+    start = (
+        0
+        if slice_args.start is None
+        else normalize_index(slice_args.start, start_message)
+    )
+    stop = (
+        None
+        if slice_args.stop is None
+        else normalize_index(slice_args.stop, stop_message)
+    )
+    step = (
+        1 if slice_args.step is None else normalize_index(slice_args.step, step_message)
+    )
+
+    if step <= 0:
+        raise ValueError(step_message)
+
+    if stop == 0 or start == stop:
+        await checkpoint()
+        return
+
+    iterator = _iterate(iterable)
+    index = 0
+    element_yielded = False
+
+    while stop is None or index < stop:
+        try:
+            element = await anext(iterator)
+        except StopAsyncIteration:
+            if not element_yielded:
+                await checkpoint()
+
+            return
+
+        if index >= start and (index - start) % step == 0:
+            index += 1
+            element_yielded = True
+            yield element
+        else:
+            index += 1
+
+    if not element_yielded:
+        await checkpoint()
+
+
+async def pairwise(
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[tuple[T, T], None]:
+    iterator = _iterate(iterable)
+    try:
+        previous = await anext(iterator)
+    except StopAsyncIteration:
+        await checkpoint()
+        return
+
+    element_yielded = False
+    async for element in iterator:
+        element_yielded = True
+        pair = (previous, element)
+        previous = element
+        yield pair
+
+    if not element_yielded:
+        await checkpoint()
+
+
+async def permutations(
+    iterable: Iterable[T] | AsyncIterable[T], r: int | None = None
+) -> AsyncGenerator[tuple[T, ...], None]:
+    pool: list[T] = [element async for element in _iterate(iterable)]
+    n = len(pool)
+    if r is None:
+        r = n
+    elif not isinstance(r, int):
+        raise TypeError("Expected int as r")
+    elif r < 0:
+        raise ValueError("r must be non-negative")
+
+    async for permutation in _iterate(itertools.permutations(pool, r)):
+        yield permutation
+
+
+async def product(
+    *iterables: Iterable[T] | AsyncIterable[T], repeat: int = 1
+) -> AsyncGenerator[tuple[T, ...], None]:
+    repeat = operator.index(repeat)
+    if repeat < 0:
+        raise ValueError("repeat argument cannot be negative")
+
+    pools: list[tuple[T, ...]] = []
+    for iterable in iterables:
+        pool: list[T] = [element async for element in _iterate(iterable)]
+        pools.append(tuple(pool))
+
+    async for value in _iterate(itertools.product(*pools, repeat=repeat)):
+        yield value
+
+
+async def repeat(element: T, times: int | None = None) -> AsyncGenerator[T, None]:
+    if times is None:
+        while True:
+            await checkpoint()
+            yield element
+
+    remaining = operator.index(cast(Any, times))
+    if remaining <= 0:
+        await checkpoint()
+        return
+
+    while remaining > 0:
+        await checkpoint_if_cancelled()
+        remaining -= 1
+        await cancel_shielded_checkpoint()
+        yield element
+
+
+async def starmap(
+    function: Callable[..., Awaitable[R]],
+    iterable: (
+        Iterable[Iterable[object] | AsyncIterable[object]]
+        | AsyncIterable[Iterable[object] | AsyncIterable[object]]
+    ),
+) -> AsyncGenerator[R, None]:
+    result_yielded = False
+
+    async for args_iterable in _iterate(iterable):
+        args = [element async for element in _iterate(args_iterable)]
+        result_yielded = True
+        yield await function(*args)
+
+    if not result_yielded:
+        await checkpoint()
+
+
+def tee(
+    iterable: Iterable[T] | AsyncIterable[T], n: int = 2
+) -> tuple[AsyncIterator[T], ...]:
+    n = operator.index(cast(Any, n))
+    if n < 0:
+        raise ValueError("n must be >= 0")
+    if n == 0:
+        return ()
+
+    iterator = _TeeAsyncIterator(iterable)
+    iterators: list[AsyncIterator[T]] = [iterator]
+    iterators.extend(_TeeAsyncIterator(iterator) for _ in range(n - 1))
+    return tuple(iterators)
+
+
+async def takewhile(
+    predicate: Callable[[T], Awaitable[object]],
+    iterable: Iterable[T] | AsyncIterable[T],
+) -> AsyncGenerator[T, None]:
+    element_yielded = False
+
+    async for element in _iterate(iterable):
+        if not await predicate(element):
+            if not element_yielded:
+                await checkpoint()
+
+            return
+
+        element_yielded = True
+        yield element
+
+    if not element_yielded:
+        await checkpoint()
+
+
+async def zip_longest(
+    *iterables: Iterable[object] | AsyncIterable[object],
+    fillvalue: object = None,
+) -> AsyncGenerator[tuple[object, ...], None]:
+    iterators = [_iterate(iterable) for iterable in iterables]
+    num_active = len(iterators)
+    if not num_active:
+        await checkpoint()
+        return
+
+    active = [True] * num_active
+    tuple_yielded = False
+
+    while True:
+        values: list[object] = []
+        for index, iterator in enumerate(iterators):
+            if not active[index]:
+                values.append(fillvalue)
+                continue
+
+            try:
+                value = await anext(iterator)
+            except StopAsyncIteration:
+                active[index] = False
+                num_active -= 1
+                if not num_active:
+                    if not tuple_yielded:
+                        await checkpoint()
+
+                    return
+
+                value = fillvalue
+
+            values.append(value)
+
+        tuple_yielded = True
+        yield tuple(values)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/lowlevel.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/lowlevel.py
new file mode 100644
index 0000000000000000000000000000000000000000..361b2eb84d3600e8c64afe9b010825fd2b8c5288
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/lowlevel.py
@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+__all__ = (
+    "EventLoopToken",
+    "RunVar",
+    "RunvarToken",
+    "cancel_shielded_checkpoint",
+    "checkpoint",
+    "checkpoint_if_cancelled",
+    "current_token",
+)
+
+import enum
+from dataclasses import dataclass
+from types import TracebackType
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, final, overload
+from weakref import WeakKeyDictionary
+
+from ._core._eventloop import get_async_backend
+
+if TYPE_CHECKING:
+    from .abc import AsyncBackend
+
+T = TypeVar("T")
+D = TypeVar("D")
+
+
+async def checkpoint() -> None:
+    """
+    Check for cancellation and allow the scheduler to switch to another task.
+
+    Equivalent to (but more efficient than)::
+
+        await checkpoint_if_cancelled()
+        await cancel_shielded_checkpoint()
+
+    .. versionadded:: 3.0
+
+    """
+    await get_async_backend().checkpoint()
+
+
+async def checkpoint_if_cancelled() -> None:
+    """
+    Enter a checkpoint if the enclosing cancel scope has been cancelled.
+
+    This does not allow the scheduler to switch to a different task.
+
+    .. versionadded:: 3.0
+
+    """
+    await get_async_backend().checkpoint_if_cancelled()
+
+
+async def cancel_shielded_checkpoint() -> None:
+    """
+    Allow the scheduler to switch to another task but without checking for cancellation.
+
+    Equivalent to (but potentially more efficient than)::
+
+        with CancelScope(shield=True):
+            await checkpoint()
+
+    .. versionadded:: 3.0
+
+    """
+    await get_async_backend().cancel_shielded_checkpoint()
+
+
+@final
+@dataclass(frozen=True, repr=False)
+class EventLoopToken:
+    """
+    An opaque object that holds a reference to an event loop.
+
+    .. versionadded:: 4.11.0
+    """
+
+    backend_class: type[AsyncBackend]
+    native_token: object
+
+
+def current_token() -> EventLoopToken:
+    """
+    Return a token object that can be used to call code in the current event loop from
+    another thread.
+
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    .. versionadded:: 4.11.0
+
+    """
+    backend_class = get_async_backend()
+    raw_token = backend_class.current_token()
+    return EventLoopToken(backend_class, raw_token)
+
+
+_run_vars: WeakKeyDictionary[object, dict[RunVar[Any], Any]] = WeakKeyDictionary()
+
+
+class _NoValueSet(enum.Enum):
+    NO_VALUE_SET = enum.auto()
+
+
+class RunvarToken(Generic[T]):
+    """
+    A token that can be used to restore a :class:`RunVar` to its previous value.
+
+    Returned by :meth:`RunVar.set`. Can be used as a context manager to automatically
+    reset the variable on exit, or passed directly to :meth:`RunVar.reset`.
+    """
+
+    __slots__ = "_redeemed", "_value", "_var"
+
+    def __init__(self, var: RunVar[T], value: T | Literal[_NoValueSet.NO_VALUE_SET]):
+        self._var = var
+        self._value: T | Literal[_NoValueSet.NO_VALUE_SET] = value
+        self._redeemed = False
+
+    def __enter__(self) -> RunvarToken[T]:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self._var.reset(self)
+
+
+class RunVar(Generic[T]):
+    """
+    Like a :class:`~contextvars.ContextVar`, except scoped to the running event loop.
+
+    Can be used as a context manager, Just like :class:`~contextvars.ContextVar`, that
+    will reset the variable to its previous value when the context block is exited.
+    """
+
+    __slots__ = "_default", "_name"
+
+    NO_VALUE_SET: Literal[_NoValueSet.NO_VALUE_SET] = _NoValueSet.NO_VALUE_SET
+
+    def __init__(
+        self, name: str, default: T | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET
+    ):
+        self._name = name
+        self._default = default
+
+    @property
+    def _current_vars(self) -> dict[RunVar[T], T]:
+        native_token = current_token().native_token
+        try:
+            return _run_vars[native_token]
+        except KeyError:
+            run_vars = _run_vars[native_token] = {}
+            return run_vars
+
+    @overload
+    def get(self, default: D) -> T | D: ...
+
+    @overload
+    def get(self) -> T: ...
+
+    def get(
+        self, default: D | Literal[_NoValueSet.NO_VALUE_SET] = NO_VALUE_SET
+    ) -> T | D:
+        """
+        Return the current value of this run variable.
+
+        :param default: a fallback value to return if no value has been set
+        :return: the current value, the provided default, or the variable's own default
+        :raises LookupError: if no value is set and no default is available
+
+        """
+        try:
+            return self._current_vars[self]
+        except KeyError:
+            if default is not RunVar.NO_VALUE_SET:
+                return default
+            elif self._default is not RunVar.NO_VALUE_SET:
+                return self._default
+
+        raise LookupError(
+            f'Run variable "{self._name}" has no value and no default set'
+        )
+
+    def set(self, value: T) -> RunvarToken[T]:
+        """
+        Set the value of this run variable for the current event loop.
+
+        :param value: the new value
+        :return: a token that can be used to restore the previous value
+
+        """
+        current_vars = self._current_vars
+        token = RunvarToken(self, current_vars.get(self, RunVar.NO_VALUE_SET))
+        current_vars[self] = value
+        return token
+
+    def reset(self, token: RunvarToken[T]) -> None:
+        """
+        Restore this run variable to the value it held before the matching :meth:`set`.
+
+        :param token: the token returned by :meth:`set`
+        :raises ValueError: if the token belongs to a different :class:`RunVar` or the token
+            has already been used
+
+        """
+        if token._var is not self:
+            raise ValueError("This token does not belong to this RunVar")
+
+        if token._redeemed:
+            raise ValueError("This token has already been used")
+
+        if token._value is _NoValueSet.NO_VALUE_SET:
+            try:
+                del self._current_vars[self]
+            except KeyError:
+                pass
+        else:
+            self._current_vars[self] = token._value
+
+        token._redeemed = True
+
+    def __repr__(self) -> str:
+        return f"<RunVar name={self._name!r}>"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/pytest_plugin.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/pytest_plugin.py
new file mode 100644
index 0000000000000000000000000000000000000000..d6238cd110ab793ccccb9671fc7eccc33c5415e5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/pytest_plugin.py
@@ -0,0 +1,404 @@
+from __future__ import annotations
+
+import dataclasses
+import socket
+import sys
+from collections.abc import Callable, Generator, Iterator
+from contextlib import ExitStack, contextmanager
+from inspect import isasyncgenfunction, iscoroutinefunction, ismethod
+from typing import TYPE_CHECKING, Any, cast
+
+import pytest
+from _pytest.fixtures import FuncFixtureInfo, SubRequest
+from _pytest.outcomes import Exit
+from _pytest.scope import Scope
+
+from . import get_available_backends
+from ._core._eventloop import (
+    current_async_library,
+    get_async_backend,
+    reset_current_async_library,
+    set_current_async_library,
+)
+from ._core._exceptions import iterate_exceptions
+
+if TYPE_CHECKING:
+    from .abc import TestRunner
+
+if sys.version_info < (3, 11):
+    from exceptiongroup import ExceptionGroup
+
+if TYPE_CHECKING:
+    # pytest >= 9.2 keeps CallSpec2 as a TYPE_CHECKING-only alias of CallSpec
+    from _pytest.python import CallSpec2 as CallSpec
+else:
+    try:
+        # c.f. https://github.com/pytest-dev/pytest/pull/14742
+        # pytest >= 9.2
+        from _pytest.python import CallSpec
+    except ImportError:
+        from _pytest.python import CallSpec2 as CallSpec
+
+_current_runner: TestRunner | None = None
+_runner_stack: ExitStack | None = None
+_runner_leases = 0
+
+
+def extract_backend_and_options(backend: object) -> tuple[str, dict[str, Any]]:
+    if isinstance(backend, str):
+        return backend, {}
+    elif isinstance(backend, tuple) and len(backend) == 2:
+        if isinstance(backend[0], str) and isinstance(backend[1], dict):
+            return cast(tuple[str, dict[str, Any]], backend)
+
+    raise TypeError("anyio_backend must be either a string or tuple of (string, dict)")
+
+
+@contextmanager
+def get_runner(
+    backend_name: str, backend_options: dict[str, Any]
+) -> Iterator[TestRunner]:
+    global _current_runner, _runner_leases, _runner_stack
+    if _current_runner is None:
+        asynclib = get_async_backend(backend_name)
+        _runner_stack = ExitStack()
+        if current_async_library() is None:
+            # Since we're in control of the event loop, we can cache the name of the
+            # async library
+            token = set_current_async_library(backend_name)
+            _runner_stack.callback(reset_current_async_library, token)
+
+        backend_options = backend_options or {}
+        _current_runner = _runner_stack.enter_context(
+            asynclib.create_test_runner(backend_options)
+        )
+
+    _runner_leases += 1
+    try:
+        yield _current_runner
+    finally:
+        _runner_leases -= 1
+        if not _runner_leases:
+            assert _runner_stack is not None
+            _runner_stack.close()
+            _runner_stack = _current_runner = None
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("anyio")
+    parser.addini(
+        "anyio_mode",
+        default="strict",
+        help='AnyIO plugin mode (either "strict" or "auto")',
+    )
+    group.addoption(
+        "--anyio-mode",
+        default=None,
+        dest="anyio_mode",
+        help="""
+        'auto'   - All async test functions will be handled by AnyIO pytest plugin
+        'strict' - Disabling autoprocessing(useful when anyio tests
+            need to coexist with other async test plugins)
+        """,
+    )
+
+
+def _is_auto_mode(config: pytest.Config, mode: str) -> bool:
+    return (
+        config.getoption(mode, default=None) == "auto" or config.getini(mode) == "auto"
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "anyio: mark the (coroutine function) test to be run asynchronously via anyio.",
+    )
+    if (
+        _is_auto_mode(config, "anyio_mode")
+        and config.pluginmanager.has_plugin("asyncio")
+        and _is_auto_mode(config, "asyncio_mode")
+    ):
+        config.issue_config_time_warning(
+            pytest.PytestConfigWarning(
+                "AnyIO auto mode has been enabled together with pytest-asyncio auto "
+                "mode. This may cause unexpected behavior."
+            ),
+            1,
+        )
+
+
+@pytest.hookimpl(hookwrapper=True)
+def pytest_fixture_setup(fixturedef: Any, request: Any) -> Generator[Any]:
+    def wrapper(anyio_backend: Any, request: SubRequest, **kwargs: Any) -> Any:
+        # Rebind any fixture methods to the request instance
+        if (
+            request.instance
+            and ismethod(func)
+            and type(func.__self__) is type(request.instance)
+        ):
+            local_func = func.__func__.__get__(request.instance)
+        else:
+            local_func = func
+
+        backend_name, backend_options = extract_backend_and_options(anyio_backend)
+        if has_backend_arg:
+            kwargs["anyio_backend"] = anyio_backend
+
+        if has_request_arg:
+            kwargs["request"] = request
+
+        with get_runner(backend_name, backend_options) as runner:
+            # re-entrant call into the test runner detected. this happens when an async fixture
+            # is dynamically requested via request.getfixturevalue() from inside a running async
+            # test or fixture. on asyncio this raises RuntimeError: This event loop is already
+            # running, on trio the runner deadlocks - the host loop blocks waiting for the
+            # coroutine to return, but the coroutine is waiting for the host loop. raising here
+            # prevents the hang and gives a consistent error across backends.
+            if runner.is_running():
+                raise RuntimeError(
+                    "Cannot schedule a coroutine in the test runner while another is already running; "
+                    "likely caused by request.getfixturevalue() on an async fixture."
+                )
+
+            if isasyncgenfunction(local_func):
+                yield from runner.run_asyncgen_fixture(local_func, kwargs)
+            else:
+                yield runner.run_fixture(local_func, kwargs)
+
+    # Only apply this to coroutine functions and async generator functions in requests
+    # that involve the anyio_backend fixture
+    func = fixturedef.func
+    if isasyncgenfunction(func) or iscoroutinefunction(func):
+        if "anyio_backend" in request.fixturenames:
+            fixturedef.func = wrapper
+            original_argname = fixturedef.argnames
+
+            if not (has_backend_arg := "anyio_backend" in fixturedef.argnames):
+                fixturedef.argnames += ("anyio_backend",)
+
+            if not (has_request_arg := "request" in fixturedef.argnames):
+                fixturedef.argnames += ("request",)
+
+            try:
+                return (yield)
+            finally:
+                fixturedef.func = func
+                fixturedef.argnames = original_argname
+
+    return (yield)
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_pycollect_makeitem(
+    collector: pytest.Module | pytest.Class, name: str, obj: object
+) -> None:
+    if collector.istestfunction(obj, name):
+        inner_func = obj.hypothesis.inner_test if hasattr(obj, "hypothesis") else obj
+        if iscoroutinefunction(inner_func):
+            anyio_auto_mode = _is_auto_mode(collector.config, "anyio_mode")
+            marker = collector.get_closest_marker("anyio")
+            own_markers = getattr(obj, "pytestmark", ())
+            if (
+                anyio_auto_mode
+                or marker
+                or any(marker.name == "anyio" for marker in own_markers)
+            ):
+                pytest.mark.usefixtures("anyio_backend")(obj)
+
+
+def pytest_collection_finish(session: pytest.Session) -> None:
+    for i, item in reversed(list(enumerate(session.items))):
+        if (
+            isinstance(item, pytest.Function)
+            and iscoroutinefunction(item.function)
+            and item.get_closest_marker("anyio") is not None
+            and "anyio_backend" not in item.fixturenames
+        ):
+            new_items = []
+            try:
+                cs_fields = {f.name for f in dataclasses.fields(CallSpec)}
+            except TypeError:
+                cs_fields = set()
+
+            for param_index, backend in enumerate(get_available_backends()):
+                if "_arg2scope" in cs_fields:  # pytest >= 8
+                    callspec = CallSpec(
+                        params={"anyio_backend": backend},
+                        indices={"anyio_backend": param_index},
+                        _arg2scope={"anyio_backend": Scope.Module},
+                        _idlist=[backend],
+                        marks=[],
+                    )
+                else:  # pytest 7.x
+                    callspec = CallSpec(  # type: ignore[call-arg]
+                        funcargs={},
+                        params={"anyio_backend": backend},
+                        indices={"anyio_backend": param_index},
+                        arg2scope={"anyio_backend": Scope.Module},
+                        idlist=[backend],
+                        marks=[],
+                    )
+
+                fi = item._fixtureinfo
+                new_names_closure = list(fi.names_closure)
+                if "anyio_backend" not in new_names_closure:
+                    new_names_closure.append("anyio_backend")
+
+                new_fixtureinfo = FuncFixtureInfo(
+                    argnames=fi.argnames,
+                    initialnames=fi.initialnames,
+                    names_closure=new_names_closure,
+                    name2fixturedefs=fi.name2fixturedefs,
+                )
+                new_item = pytest.Function.from_parent(
+                    item.parent,
+                    name=f"{item.originalname}[{backend}]",
+                    callspec=callspec,
+                    callobj=item.obj,
+                    fixtureinfo=new_fixtureinfo,
+                    keywords=item.keywords,
+                    originalname=item.originalname,
+                )
+                new_items.append(new_item)
+
+            session.items[i : i + 1] = new_items
+
+
+@pytest.hookimpl(tryfirst=True)
+def pytest_pyfunc_call(pyfuncitem: Any) -> bool | None:
+    def run_with_hypothesis(**kwargs: Any) -> None:
+        with get_runner(backend_name, backend_options) as runner:
+            runner.run_test(original_func, kwargs)
+
+    backend = pyfuncitem.funcargs.get("anyio_backend")
+    if backend:
+        backend_name, backend_options = extract_backend_and_options(backend)
+
+        if hasattr(pyfuncitem.obj, "hypothesis"):
+            # Wrap the inner test function unless it's already wrapped
+            original_func = pyfuncitem.obj.hypothesis.inner_test
+            if original_func.__qualname__ != run_with_hypothesis.__qualname__:
+                if iscoroutinefunction(original_func):
+                    pyfuncitem.obj.hypothesis.inner_test = run_with_hypothesis
+
+            return None
+
+        if iscoroutinefunction(pyfuncitem.obj):
+            funcargs = pyfuncitem.funcargs
+            testargs = {arg: funcargs[arg] for arg in pyfuncitem._fixtureinfo.argnames}
+            with get_runner(backend_name, backend_options) as runner:
+                try:
+                    runner.run_test(pyfuncitem.obj, testargs)
+                except ExceptionGroup as excgrp:
+                    for exc in iterate_exceptions(excgrp):
+                        if isinstance(exc, (Exit, KeyboardInterrupt, SystemExit)):
+                            raise exc from excgrp
+
+                    raise
+
+            return True
+
+    return None
+
+
+@pytest.fixture(scope="module", params=get_available_backends())
+def anyio_backend(request: Any) -> Any:
+    return request.param
+
+
+@pytest.fixture
+def anyio_backend_name(anyio_backend: Any) -> str:
+    if isinstance(anyio_backend, str):
+        return anyio_backend
+    else:
+        return anyio_backend[0]
+
+
+@pytest.fixture
+def anyio_backend_options(anyio_backend: Any) -> dict[str, Any]:
+    if isinstance(anyio_backend, str):
+        return {}
+    else:
+        return anyio_backend[1]
+
+
+class FreePortFactory:
+    """
+    Manages port generation based on specified socket kind, ensuring no duplicate
+    ports are generated.
+
+    This class provides functionality for generating available free ports on the
+    system. It is initialized with a specific socket kind and can generate ports
+    for given address families while avoiding reuse of previously generated ports.
+
+    Users should not instantiate this class directly, but use the
+    ``free_tcp_port_factory`` and ``free_udp_port_factory`` fixtures instead. For simple
+    uses cases, ``free_tcp_port`` and ``free_udp_port`` can be used instead.
+    """
+
+    def __init__(self, kind: socket.SocketKind) -> None:
+        self._kind = kind
+        self._generated = set[int]()
+
+    @property
+    def kind(self) -> socket.SocketKind:
+        """
+        The type of socket connection (e.g., :data:`~socket.SOCK_STREAM` or
+        :data:`~socket.SOCK_DGRAM`) used to bind for checking port availability
+
+        """
+        return self._kind
+
+    def __call__(self, family: socket.AddressFamily | None = None) -> int:
+        """
+        Return an unbound port for the given address family.
+
+        :param family: if omitted, both IPv4 and IPv6 addresses will be tried
+        :return: a port number
+
+        """
+        if family is not None:
+            families = [family]
+        else:
+            families = [socket.AF_INET]
+            if socket.has_ipv6:
+                families.append(socket.AF_INET6)
+
+        while True:
+            port = 0
+            with ExitStack() as stack:
+                for fam in families:
+                    sock = stack.enter_context(socket.socket(fam, self._kind))
+                    addr = "::1" if fam == socket.AF_INET6 else "127.0.0.1"
+                    try:
+                        sock.bind((addr, port))
+                    except OSError:
+                        break
+
+                    if not port:
+                        port = sock.getsockname()[1]
+                else:
+                    if port not in self._generated:
+                        self._generated.add(port)
+                        return port
+
+
+@pytest.fixture(scope="session")
+def free_tcp_port_factory() -> FreePortFactory:
+    return FreePortFactory(socket.SOCK_STREAM)
+
+
+@pytest.fixture(scope="session")
+def free_udp_port_factory() -> FreePortFactory:
+    return FreePortFactory(socket.SOCK_DGRAM)
+
+
+@pytest.fixture
+def free_tcp_port(free_tcp_port_factory: Callable[[], int]) -> int:
+    return free_tcp_port_factory()
+
+
+@pytest.fixture
+def free_udp_port(free_udp_port_factory: Callable[[], int]) -> int:
+    return free_udp_port_factory()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..82ba387675ab94ea219f349ba06a6760517351ee
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/buffered.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/buffered.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa2de644f76797e45a7edd6bee86257b7cb7f18e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/buffered.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/file.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/file.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b197d3a01a701af96c0d186e903dcc644e841732
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/file.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/memory.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/memory.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f6465d657ca059826bf4635642b31fec708d3bd6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/memory.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/stapled.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/stapled.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49201b913681f2e8a38f674edbf388e13e9fe8c7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/stapled.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/text.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/text.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e91a02f5d9e0e4e2ac14f3fe7ede407a048b3712
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/text.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/tls.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/tls.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1ed48f60106709cdd38cbf50cad6f64f66e7399a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/__pycache__/tls.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/buffered.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/buffered.py
new file mode 100644
index 0000000000000000000000000000000000000000..a3b07f73ac44d5876c239fd0317846564ef06f91
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/buffered.py
@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+__all__ = (
+    "BufferedByteReceiveStream",
+    "BufferedByteStream",
+    "BufferedConnectable",
+)
+
+import sys
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import dataclass, field
+from typing import Any, SupportsIndex
+
+from .. import ClosedResourceError, DelimiterNotFound, EndOfStream, IncompleteRead
+from ..abc import (
+    AnyByteReceiveStream,
+    AnyByteStream,
+    AnyByteStreamConnectable,
+    ByteReceiveStream,
+    ByteStream,
+    ByteStreamConnectable,
+)
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+
+@dataclass(eq=False)
+class BufferedByteReceiveStream(ByteReceiveStream):
+    """
+    Wraps any bytes-based receive stream and uses a buffer to provide sophisticated
+    receiving capabilities in the form of a byte stream.
+    """
+
+    receive_stream: AnyByteReceiveStream
+    _buffer: bytearray = field(init=False, default_factory=bytearray)
+    _closed: bool = field(init=False, default=False)
+
+    async def aclose(self) -> None:
+        await self.receive_stream.aclose()
+        self._closed = True
+
+    @property
+    def buffer(self) -> bytes:
+        """The bytes currently in the buffer."""
+        return bytes(self._buffer)
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.receive_stream.extra_attributes
+
+    def feed_data(self, data: Iterable[SupportsIndex], /) -> None:
+        """
+        Append data directly into the buffer.
+
+        Any data in the buffer will be consumed by receive operations before receiving
+        anything from the wrapped stream.
+
+        :param data: the data to append to the buffer (can be bytes or anything else
+            that supports ``__index__()``)
+
+        """
+        self._buffer.extend(data)
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        if self._closed:
+            raise ClosedResourceError
+
+        if self._buffer:
+            chunk = bytes(self._buffer[:max_bytes])
+            del self._buffer[:max_bytes]
+            return chunk
+        elif isinstance(self.receive_stream, ByteReceiveStream):
+            return await self.receive_stream.receive(max_bytes)
+        else:
+            # With a bytes-oriented object stream, we need to handle any surplus bytes
+            # we get from the receive() call
+            chunk = await self.receive_stream.receive()
+            if len(chunk) > max_bytes:
+                # Save the surplus bytes in the buffer
+                self._buffer.extend(chunk[max_bytes:])
+                return chunk[:max_bytes]
+            else:
+                return chunk
+
+    async def receive_exactly(self, nbytes: int) -> bytes:
+        """
+        Read exactly the given amount of bytes from the stream.
+
+        :param nbytes: the number of bytes to read
+        :return: the bytes read
+        :raises ~anyio.IncompleteRead: if the stream was closed before the requested
+            amount of bytes could be read from the stream
+
+        """
+        while True:
+            remaining = nbytes - len(self._buffer)
+            if remaining <= 0:
+                retval = self._buffer[:nbytes]
+                del self._buffer[:nbytes]
+                return bytes(retval)
+
+            try:
+                if isinstance(self.receive_stream, ByteReceiveStream):
+                    chunk = await self.receive_stream.receive(remaining)
+                else:
+                    chunk = await self.receive_stream.receive()
+            except EndOfStream as exc:
+                raise IncompleteRead from exc
+
+            self._buffer.extend(chunk)
+
+    async def receive_until(self, delimiter: bytes, max_bytes: int) -> bytes:
+        """
+        Read from the stream until the delimiter is found or max_bytes have been read.
+
+        :param delimiter: the marker to look for in the stream
+        :param max_bytes: maximum number of bytes that will be read before raising
+            :exc:`~anyio.DelimiterNotFound`
+        :return: the bytes read (not including the delimiter)
+        :raises ~anyio.IncompleteRead: if the stream was closed before the delimiter
+            was found
+        :raises ~anyio.DelimiterNotFound: if the delimiter is not found within the
+            bytes read up to the maximum allowed
+
+        """
+        delimiter_size = len(delimiter)
+        offset = 0
+        while True:
+            # Check if the delimiter can be found in the current buffer
+            index = self._buffer.find(delimiter, offset)
+            if index >= 0:
+                found = self._buffer[:index]
+                del self._buffer[: index + len(delimiter) :]
+                return bytes(found)
+
+            # Check if the buffer is already at or over the limit
+            if len(self._buffer) >= max_bytes:
+                raise DelimiterNotFound(max_bytes)
+
+            # Read more data into the buffer from the socket
+            try:
+                data = await self.receive_stream.receive()
+            except EndOfStream as exc:
+                raise IncompleteRead from exc
+
+            # Move the offset forward and add the new data to the buffer
+            offset = max(len(self._buffer) - delimiter_size + 1, 0)
+            self._buffer.extend(data)
+
+
+class BufferedByteStream(BufferedByteReceiveStream, ByteStream):
+    """
+    A full-duplex variant of :class:`BufferedByteReceiveStream`. All writes are passed
+    through to the wrapped stream as-is.
+    """
+
+    def __init__(self, stream: AnyByteStream):
+        """
+        :param stream: the stream to be wrapped
+
+        """
+        super().__init__(stream)
+        self._stream = stream
+
+    @override
+    async def send_eof(self) -> None:
+        await self._stream.send_eof()
+
+    @override
+    async def send(self, item: bytes) -> None:
+        await self._stream.send(item)
+
+
+class BufferedConnectable(ByteStreamConnectable):
+    """
+    Wraps a byte stream connectable to produce :class:`BufferedByteStream` connections.
+
+    Use this when you want the streams returned by :meth:`connect` to have the buffered
+    receive API (e.g. :meth:`~BufferedByteReceiveStream.receive_exactly` and
+    :meth:`~BufferedByteReceiveStream.receive_until`).
+
+    :param connectable: the byte stream connectable to wrap
+    """
+
+    def __init__(self, connectable: AnyByteStreamConnectable):
+        """
+        :param connectable: the connectable to wrap
+
+        """
+        self.connectable = connectable
+
+    @override
+    async def connect(self) -> BufferedByteStream:
+        stream = await self.connectable.connect()
+        return BufferedByteStream(stream)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/file.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9d7ca4f3341a7ad7e44553e4e15134f223cb750
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/file.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+__all__ = (
+    "FileReadStream",
+    "FileStreamAttribute",
+    "FileWriteStream",
+)
+
+from collections.abc import Callable, Mapping
+from io import SEEK_SET, UnsupportedOperation
+from os import PathLike
+from pathlib import Path
+from typing import IO, Any
+
+from .. import (
+    BrokenResourceError,
+    ClosedResourceError,
+    EndOfStream,
+    TypedAttributeSet,
+    to_thread,
+    typed_attribute,
+)
+from ..abc import ByteReceiveStream, ByteSendStream
+
+
+class FileStreamAttribute(TypedAttributeSet):
+    #: the open file descriptor
+    file: IO[bytes] = typed_attribute()
+    #: the path of the file on the file system, if available (file must be a real file)
+    path: Path = typed_attribute()
+    #: the file number, if available (file must be a real file or a TTY)
+    fileno: int = typed_attribute()
+
+
+class _BaseFileStream:
+    def __init__(self, file: IO[bytes]):
+        self._file = file
+
+    async def aclose(self) -> None:
+        await to_thread.run_sync(self._file.close)
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        attributes: dict[Any, Callable[[], Any]] = {
+            FileStreamAttribute.file: lambda: self._file,
+        }
+
+        if hasattr(self._file, "name"):
+            attributes[FileStreamAttribute.path] = lambda: Path(self._file.name)
+
+        try:
+            self._file.fileno()
+        except UnsupportedOperation:
+            pass
+        else:
+            attributes[FileStreamAttribute.fileno] = lambda: self._file.fileno()
+
+        return attributes
+
+
+class FileReadStream(_BaseFileStream, ByteReceiveStream):
+    """
+    A byte stream that reads from a file in the file system.
+
+    :param file: a file that has been opened for reading in binary mode
+
+    .. versionadded:: 3.0
+    """
+
+    @classmethod
+    async def from_path(cls, path: str | PathLike[str]) -> FileReadStream:
+        """
+        Create a file read stream by opening the given file.
+
+        :param path: path of the file to read from
+
+        """
+        file = await to_thread.run_sync(Path(path).open, "rb")
+        return cls(file)
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        try:
+            data = await to_thread.run_sync(self._file.read, max_bytes)
+        except ValueError:
+            raise ClosedResourceError from None
+        except OSError as exc:
+            raise BrokenResourceError from exc
+
+        if data:
+            return data
+        else:
+            raise EndOfStream
+
+    async def seek(self, position: int, whence: int = SEEK_SET) -> int:
+        """
+        Seek the file to the given position.
+
+        .. seealso:: :meth:`io.IOBase.seek`
+
+        .. note:: Not all file descriptors are seekable.
+
+        :param position: position to seek the file to
+        :param whence: controls how ``position`` is interpreted
+        :return: the new absolute position
+        :raises OSError: if the file is not seekable
+
+        """
+        return await to_thread.run_sync(self._file.seek, position, whence)
+
+    async def tell(self) -> int:
+        """
+        Return the current stream position.
+
+        .. note:: Not all file descriptors are seekable.
+
+        :return: the current absolute position
+        :raises OSError: if the file is not seekable
+
+        """
+        return await to_thread.run_sync(self._file.tell)
+
+
+class FileWriteStream(_BaseFileStream, ByteSendStream):
+    """
+    A byte stream that writes to a file in the file system.
+
+    :param file: a file that has been opened for writing in binary mode
+
+    .. versionadded:: 3.0
+    """
+
+    @classmethod
+    async def from_path(
+        cls, path: str | PathLike[str], append: bool = False
+    ) -> FileWriteStream:
+        """
+        Create a file write stream by opening the given file for writing.
+
+        :param path: path of the file to write to
+        :param append: if ``True``, open the file for appending; if ``False``, any
+            existing file at the given path will be truncated
+
+        """
+        mode = "ab" if append else "wb"
+        file = await to_thread.run_sync(Path(path).open, mode)
+        return cls(file)
+
+    async def send(self, item: bytes) -> None:
+        try:
+            await to_thread.run_sync(self._file.write, item)
+        except ValueError:
+            raise ClosedResourceError from None
+        except OSError as exc:
+            raise BrokenResourceError from exc
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/memory.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..329a75e44b7af979042c54e65529c7148e67cd8d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/memory.py
@@ -0,0 +1,326 @@
+from __future__ import annotations
+
+__all__ = (
+    "MemoryObjectReceiveStream",
+    "MemoryObjectSendStream",
+    "MemoryObjectStreamStatistics",
+)
+
+import warnings
+from collections import OrderedDict, deque
+from dataclasses import dataclass, field
+from types import TracebackType
+from typing import Generic, NamedTuple, TypeVar
+
+from .._core._exceptions import (
+    BrokenResourceError,
+    ClosedResourceError,
+    EndOfStream,
+    WouldBlock,
+)
+from .._core._synchronization import Event
+from .._core._testing import TaskInfo, get_current_task
+from ..abc import ObjectReceiveStream, ObjectSendStream
+from ..lowlevel import checkpoint
+
+T_Item = TypeVar("T_Item")
+T_co = TypeVar("T_co", covariant=True)
+T_contra = TypeVar("T_contra", contravariant=True)
+
+
+class MemoryObjectStreamStatistics(NamedTuple):
+    current_buffer_used: int  #: number of items stored in the buffer
+    #: maximum number of items that can be stored on this stream (or :data:`math.inf`)
+    max_buffer_size: float
+    open_send_streams: int  #: number of unclosed clones of the send stream
+    open_receive_streams: int  #: number of unclosed clones of the receive stream
+    #: number of tasks blocked on :meth:`MemoryObjectSendStream.send`
+    tasks_waiting_send: int
+    #: number of tasks blocked on :meth:`MemoryObjectReceiveStream.receive`
+    tasks_waiting_receive: int
+
+
+@dataclass(eq=False)
+class _MemoryObjectItemReceiver(Generic[T_Item]):
+    task_info: TaskInfo = field(init=False, default_factory=get_current_task)
+    item: T_Item = field(init=False)
+
+    def __repr__(self) -> str:
+        # When item is not defined, we get following error with default __repr__:
+        # AttributeError: 'MemoryObjectItemReceiver' object has no attribute 'item'
+        item = getattr(self, "item", None)
+        return f"{self.__class__.__name__}(task_info={self.task_info}, item={item!r})"
+
+
+@dataclass(eq=False)
+class _MemoryObjectStreamState(Generic[T_Item]):
+    max_buffer_size: float = field()
+    buffer: deque[T_Item] = field(init=False, default_factory=deque)
+    open_send_channels: int = field(init=False, default=0)
+    open_receive_channels: int = field(init=False, default=0)
+    waiting_receivers: OrderedDict[Event, _MemoryObjectItemReceiver[T_Item]] = field(
+        init=False, default_factory=OrderedDict
+    )
+    waiting_senders: OrderedDict[Event, T_Item] = field(
+        init=False, default_factory=OrderedDict
+    )
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        return MemoryObjectStreamStatistics(
+            len(self.buffer),
+            self.max_buffer_size,
+            self.open_send_channels,
+            self.open_receive_channels,
+            len(self.waiting_senders),
+            len(self.waiting_receivers),
+        )
+
+
+@dataclass(eq=False)
+class MemoryObjectReceiveStream(ObjectReceiveStream[T_co], Generic[T_co]):
+    _state: _MemoryObjectStreamState[T_co]
+    _closed: bool = field(init=False, default=False)
+
+    def __post_init__(self) -> None:
+        self._state.open_receive_channels += 1
+
+    def receive_nowait(self) -> T_co:
+        """
+        Receive the next item if it can be done without waiting.
+
+        :return: the received item
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.EndOfStream: if the buffer is empty and this stream has been
+            closed from the sending end
+        :raises ~anyio.WouldBlock: if there are no items in the buffer and no tasks
+            waiting to send
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        if self._state.waiting_senders:
+            # Get the item from the next sender
+            send_event, item = self._state.waiting_senders.popitem(last=False)
+            self._state.buffer.append(item)
+            send_event.set()
+
+        if self._state.buffer:
+            return self._state.buffer.popleft()
+        elif not self._state.open_send_channels:
+            raise EndOfStream
+
+        raise WouldBlock
+
+    async def receive(self) -> T_co:
+        await checkpoint()
+        try:
+            return self.receive_nowait()
+        except WouldBlock:
+            # Add ourselves in the queue
+            receive_event = Event()
+            receiver = _MemoryObjectItemReceiver[T_co]()
+            self._state.waiting_receivers[receive_event] = receiver
+
+            try:
+                await receive_event.wait()
+            finally:
+                self._state.waiting_receivers.pop(receive_event, None)
+
+            try:
+                return receiver.item
+            except AttributeError:
+                raise EndOfStream from None
+
+    def clone(self) -> MemoryObjectReceiveStream[T_co]:
+        """
+        Create a clone of this receive stream.
+
+        Each clone can be closed separately. Only when all clones have been closed will
+        the receiving end of the memory stream be considered closed by the sending ends.
+
+        :return: the cloned stream
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        return MemoryObjectReceiveStream(_state=self._state)
+
+    def close(self) -> None:
+        """
+        Close the stream.
+
+        This works the exact same way as :meth:`aclose`, but is provided as a special
+        case for the benefit of synchronous callbacks.
+
+        """
+        if not self._closed:
+            self._closed = True
+            self._state.open_receive_channels -= 1
+            if self._state.open_receive_channels == 0:
+                send_events = list(self._state.waiting_senders.keys())
+                for event in send_events:
+                    event.set()
+
+    async def aclose(self) -> None:
+        self.close()
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        """
+        Return statistics about the current state of this stream.
+
+        .. versionadded:: 3.0
+        """
+        return self._state.statistics()
+
+    def __enter__(self) -> MemoryObjectReceiveStream[T_co]:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        if not self._closed:
+            warnings.warn(
+                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
+                ResourceWarning,
+                stacklevel=1,
+                source=self,
+            )
+
+
+@dataclass(eq=False)
+class MemoryObjectSendStream(ObjectSendStream[T_contra], Generic[T_contra]):
+    _state: _MemoryObjectStreamState[T_contra]
+    _closed: bool = field(init=False, default=False)
+
+    def __post_init__(self) -> None:
+        self._state.open_send_channels += 1
+
+    def send_nowait(self, item: T_contra) -> None:
+        """
+        Send an item immediately if it can be done without waiting.
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
+            receiving end
+        :raises ~anyio.WouldBlock: if the buffer is full and there are no tasks waiting
+            to receive
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+        if not self._state.open_receive_channels:
+            raise BrokenResourceError
+
+        while self._state.waiting_receivers:
+            receive_event, receiver = self._state.waiting_receivers.popitem(last=False)
+            if not receiver.task_info.has_pending_cancellation():
+                receiver.item = item
+                receive_event.set()
+                return
+
+        if len(self._state.buffer) < self._state.max_buffer_size:
+            self._state.buffer.append(item)
+        else:
+            raise WouldBlock
+
+    async def send(self, item: T_contra) -> None:
+        """
+        Send an item to the stream.
+
+        If the buffer is full, this method blocks until there is again room in the
+        buffer or the item can be sent directly to a receiver.
+
+        :param item: the item to send
+        :raises ~anyio.ClosedResourceError: if this send stream has been closed
+        :raises ~anyio.BrokenResourceError: if the stream has been closed from the
+            receiving end
+
+        """
+        await checkpoint()
+        try:
+            self.send_nowait(item)
+        except WouldBlock:
+            # Wait until there's someone on the receiving end
+            send_event = Event()
+            self._state.waiting_senders[send_event] = item
+            try:
+                await send_event.wait()
+            except BaseException:
+                self._state.waiting_senders.pop(send_event, None)
+                raise
+
+            if send_event in self._state.waiting_senders:
+                del self._state.waiting_senders[send_event]
+                raise BrokenResourceError from None
+
+    def clone(self) -> MemoryObjectSendStream[T_contra]:
+        """
+        Create a clone of this send stream.
+
+        Each clone can be closed separately. Only when all clones have been closed will
+        the sending end of the memory stream be considered closed by the receiving ends.
+
+        :return: the cloned stream
+
+        """
+        if self._closed:
+            raise ClosedResourceError
+
+        return MemoryObjectSendStream(_state=self._state)
+
+    def close(self) -> None:
+        """
+        Close the stream.
+
+        This works the exact same way as :meth:`aclose`, but is provided as a special
+        case for the benefit of synchronous callbacks.
+
+        """
+        if not self._closed:
+            self._closed = True
+            self._state.open_send_channels -= 1
+            if self._state.open_send_channels == 0:
+                receive_events = list(self._state.waiting_receivers.keys())
+                self._state.waiting_receivers.clear()
+                for event in receive_events:
+                    event.set()
+
+    async def aclose(self) -> None:
+        self.close()
+
+    def statistics(self) -> MemoryObjectStreamStatistics:
+        """
+        Return statistics about the current state of this stream.
+
+        .. versionadded:: 3.0
+        """
+        return self._state.statistics()
+
+    def __enter__(self) -> MemoryObjectSendStream[T_contra]:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        self.close()
+
+    def __del__(self) -> None:
+        if not self._closed:
+            warnings.warn(
+                f"Unclosed <{self.__class__.__name__} at {id(self):x}>",
+                ResourceWarning,
+                stacklevel=1,
+                source=self,
+            )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/stapled.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/stapled.py
new file mode 100644
index 0000000000000000000000000000000000000000..9a7534563b1aa9613516cd468daf6e68b4fa8a71
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/stapled.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+__all__ = (
+    "MultiListener",
+    "StapledByteStream",
+    "StapledObjectStream",
+)
+
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import dataclass
+from typing import Any, Generic, TypeVar
+
+from ..abc import (
+    ByteReceiveStream,
+    ByteSendStream,
+    ByteStream,
+    Listener,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    TaskGroup,
+)
+
+T_Item = TypeVar("T_Item")
+T_Stream = TypeVar("T_Stream")
+
+
+@dataclass(eq=False)
+class StapledByteStream(ByteStream):
+    """
+    Combines two byte streams into a single, bidirectional byte stream.
+
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
+
+    :param ByteSendStream send_stream: the sending byte stream
+    :param ByteReceiveStream receive_stream: the receiving byte stream
+    """
+
+    send_stream: ByteSendStream
+    receive_stream: ByteReceiveStream
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        return await self.receive_stream.receive(max_bytes)
+
+    async def send(self, item: bytes) -> None:
+        await self.send_stream.send(item)
+
+    async def send_eof(self) -> None:
+        await self.send_stream.aclose()
+
+    async def aclose(self) -> None:
+        await self.send_stream.aclose()
+        await self.receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.send_stream.extra_attributes,
+            **self.receive_stream.extra_attributes,
+        }
+
+
+@dataclass(eq=False)
+class StapledObjectStream(ObjectStream[T_Item], Generic[T_Item]):
+    """
+    Combines two object streams into a single, bidirectional object stream.
+
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
+
+    :param ObjectSendStream send_stream: the sending object stream
+    :param ObjectReceiveStream receive_stream: the receiving object stream
+    """
+
+    send_stream: ObjectSendStream[T_Item]
+    receive_stream: ObjectReceiveStream[T_Item]
+
+    async def receive(self) -> T_Item:
+        return await self.receive_stream.receive()
+
+    async def send(self, item: T_Item) -> None:
+        await self.send_stream.send(item)
+
+    def send_nowait(self, item: T_Item) -> None:
+        try:
+            send_nowait = self.send_stream.send_nowait  # type: ignore[attr-defined]
+        except AttributeError as exc:
+            raise NotImplementedError(
+                f"'send_nowait' method not implemented in {type(self.send_stream)}"
+            ) from exc
+
+        send_nowait(item)
+
+    async def send_eof(self) -> None:
+        await self.send_stream.aclose()
+
+    async def aclose(self) -> None:
+        await self.send_stream.aclose()
+        await self.receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.send_stream.extra_attributes,
+            **self.receive_stream.extra_attributes,
+        }
+
+
+@dataclass(eq=False)
+class MultiListener(Listener[T_Stream], Generic[T_Stream]):
+    """
+    Combines multiple listeners into one, serving connections from all of them at once.
+
+    Any MultiListeners in the given collection of listeners will have their listeners
+    moved into this one.
+
+    Extra attributes are provided from each listener, with each successive listener
+    overriding any conflicting attributes from the previous one.
+
+    :param listeners: listeners to serve
+    :type listeners: Sequence[Listener[T_Stream]]
+    """
+
+    listeners: Sequence[Listener[T_Stream]]
+
+    def __post_init__(self) -> None:
+        listeners: list[Listener[T_Stream]] = []
+        for listener in self.listeners:
+            if isinstance(listener, MultiListener):
+                listeners.extend(listener.listeners)
+                del listener.listeners[:]  # type: ignore[attr-defined]
+            else:
+                listeners.append(listener)
+
+        self.listeners = listeners
+
+    async def serve(
+        self, handler: Callable[[T_Stream], Any], task_group: TaskGroup | None = None
+    ) -> None:
+        from .. import create_task_group
+
+        async with create_task_group() as tg:
+            for listener in self.listeners:
+                tg.start_soon(listener.serve, handler, task_group)
+
+    async def aclose(self) -> None:
+        for listener in self.listeners:
+            await listener.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        attributes: dict = {}
+        for listener in self.listeners:
+            attributes.update(listener.extra_attributes)
+
+        return attributes
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/text.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/text.py
new file mode 100644
index 0000000000000000000000000000000000000000..296cd250459f3848bb333301fff1ac32973f219a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/text.py
@@ -0,0 +1,176 @@
+from __future__ import annotations
+
+__all__ = (
+    "TextConnectable",
+    "TextReceiveStream",
+    "TextSendStream",
+    "TextStream",
+)
+
+import codecs
+import sys
+from collections.abc import Callable, Mapping
+from dataclasses import InitVar, dataclass, field
+from typing import Any
+
+from ..abc import (
+    AnyByteReceiveStream,
+    AnyByteSendStream,
+    AnyByteStream,
+    AnyByteStreamConnectable,
+    ObjectReceiveStream,
+    ObjectSendStream,
+    ObjectStream,
+    ObjectStreamConnectable,
+)
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+
+@dataclass(eq=False)
+class TextReceiveStream(ObjectReceiveStream[str]):
+    """
+    Stream wrapper that decodes bytes to strings using the given encoding.
+
+    Decoding is done using :class:`~codecs.IncrementalDecoder` which returns any
+    completely received unicode characters as soon as they come in.
+
+    :param transport_stream: any bytes-based receive stream
+    :param encoding: character encoding to use for decoding bytes to strings (defaults
+        to ``utf-8``)
+    :param errors: handling scheme for decoding errors (defaults to ``strict``; see the
+        `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteReceiveStream
+    encoding: InitVar[str] = "utf-8"
+    errors: InitVar[str] = "strict"
+    _decoder: codecs.IncrementalDecoder = field(init=False)
+
+    def __post_init__(self, encoding: str, errors: str) -> None:
+        decoder_class = codecs.getincrementaldecoder(encoding)
+        self._decoder = decoder_class(errors=errors)
+
+    async def receive(self) -> str:
+        while True:
+            chunk = await self.transport_stream.receive()
+            decoded = self._decoder.decode(chunk)
+            if decoded:
+                return decoded
+
+    async def aclose(self) -> None:
+        await self.transport_stream.aclose()
+        self._decoder.reset()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.transport_stream.extra_attributes
+
+
+@dataclass(eq=False)
+class TextSendStream(ObjectSendStream[str]):
+    """
+    Sends strings to the wrapped stream as bytes using the given encoding.
+
+    :param AnyByteSendStream transport_stream: any bytes-based send stream
+    :param str encoding: character encoding to use for encoding strings to bytes
+        (defaults to ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
+        the `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteSendStream
+    encoding: InitVar[str] = "utf-8"
+    errors: str = "strict"
+    _encoder: Callable[..., tuple[bytes, int]] = field(init=False)
+
+    def __post_init__(self, encoding: str) -> None:
+        self._encoder = codecs.getencoder(encoding)
+
+    async def send(self, item: str) -> None:
+        encoded = self._encoder(item, self.errors)[0]
+        await self.transport_stream.send(encoded)
+
+    async def aclose(self) -> None:
+        await self.transport_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return self.transport_stream.extra_attributes
+
+
+@dataclass(eq=False)
+class TextStream(ObjectStream[str]):
+    """
+    A bidirectional stream that decodes bytes to strings on receive and encodes strings
+    to bytes on send.
+
+    Extra attributes will be provided from both streams, with the receive stream
+    providing the values in case of a conflict.
+
+    :param AnyByteStream transport_stream: any bytes-based stream
+    :param str encoding: character encoding to use for encoding/decoding strings to/from
+        bytes (defaults to ``utf-8``)
+    :param str errors: handling scheme for encoding errors (defaults to ``strict``; see
+        the `codecs module documentation`_ for a comprehensive list of options)
+
+    .. _codecs module documentation:
+        https://docs.python.org/3/library/codecs.html#codec-objects
+    """
+
+    transport_stream: AnyByteStream
+    encoding: InitVar[str] = "utf-8"
+    errors: InitVar[str] = "strict"
+    _receive_stream: TextReceiveStream = field(init=False)
+    _send_stream: TextSendStream = field(init=False)
+
+    def __post_init__(self, encoding: str, errors: str) -> None:
+        self._receive_stream = TextReceiveStream(
+            self.transport_stream, encoding=encoding, errors=errors
+        )
+        self._send_stream = TextSendStream(
+            self.transport_stream, encoding=encoding, errors=errors
+        )
+
+    async def receive(self) -> str:
+        return await self._receive_stream.receive()
+
+    async def send(self, item: str) -> None:
+        await self._send_stream.send(item)
+
+    async def send_eof(self) -> None:
+        await self.transport_stream.send_eof()
+
+    async def aclose(self) -> None:
+        await self._send_stream.aclose()
+        await self._receive_stream.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self._send_stream.extra_attributes,
+            **self._receive_stream.extra_attributes,
+        }
+
+
+class TextConnectable(ObjectStreamConnectable[str]):
+    def __init__(self, connectable: AnyByteStreamConnectable):
+        """
+        :param connectable: the bytestream endpoint to wrap
+
+        """
+        self.connectable = connectable
+
+    @override
+    async def connect(self) -> TextStream:
+        stream = await self.connectable.connect()
+        return TextStream(stream)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/tls.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/tls.py
new file mode 100644
index 0000000000000000000000000000000000000000..b9ddf1d333143767b737bbd5915bebe1309481b2
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/streams/tls.py
@@ -0,0 +1,436 @@
+from __future__ import annotations
+
+__all__ = (
+    "TLSAttribute",
+    "TLSConnectable",
+    "TLSListener",
+    "TLSStream",
+)
+
+import logging
+import re
+import ssl
+import sys
+from collections.abc import Callable, Mapping
+from dataclasses import dataclass
+from functools import wraps
+from ssl import SSLContext
+from typing import Any, TypeAlias, TypeVar
+
+from .. import (
+    BrokenResourceError,
+    EndOfStream,
+    aclose_forcefully,
+    get_cancelled_exc_class,
+    to_thread,
+)
+from .._core._typedattr import TypedAttributeSet, typed_attribute
+from ..abc import (
+    AnyByteStream,
+    AnyByteStreamConnectable,
+    ByteStream,
+    ByteStreamConnectable,
+    Listener,
+    TaskGroup,
+)
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from typing_extensions import override
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+_PCTRTT: TypeAlias = tuple[tuple[str, str], ...]
+_PCTRTTT: TypeAlias = tuple[_PCTRTT, ...]
+
+
+class TLSAttribute(TypedAttributeSet):
+    """Contains Transport Layer Security related attributes."""
+
+    #: the selected ALPN protocol
+    alpn_protocol: str | None = typed_attribute()
+    #: the channel binding for type ``tls-unique``
+    channel_binding_tls_unique: bytes = typed_attribute()
+    #: the selected cipher
+    cipher: tuple[str, str, int] = typed_attribute()
+    #: the peer certificate in dictionary form (see :meth:`ssl.SSLSocket.getpeercert`
+    # for more information)
+    peer_certificate: None | (dict[str, str | _PCTRTTT | _PCTRTT]) = typed_attribute()
+    #: the peer certificate in binary form
+    peer_certificate_binary: bytes | None = typed_attribute()
+    #: ``True`` if this is the server side of the connection
+    server_side: bool = typed_attribute()
+    #: ciphers shared by the client during the TLS handshake (``None`` if this is the
+    #: client side)
+    shared_ciphers: list[tuple[str, str, int]] | None = typed_attribute()
+    #: the :class:`~ssl.SSLObject` used for encryption
+    ssl_object: ssl.SSLObject = typed_attribute()
+    #: ``True`` if this stream does (and expects) a closing TLS handshake when the
+    #: stream is being closed
+    standard_compatible: bool = typed_attribute()
+    #: the TLS protocol version (e.g. ``TLSv1.2``)
+    tls_version: str = typed_attribute()
+
+
+@dataclass(eq=False)
+class TLSStream(ByteStream):
+    """
+    A stream wrapper that encrypts all sent data and decrypts received data.
+
+    This class has no public initializer; use :meth:`wrap` instead.
+    All extra attributes from :class:`~TLSAttribute` are supported.
+
+    :var AnyByteStream transport_stream: the wrapped stream
+
+    """
+
+    transport_stream: AnyByteStream
+    standard_compatible: bool
+    _ssl_object: ssl.SSLObject
+    _read_bio: ssl.MemoryBIO
+    _write_bio: ssl.MemoryBIO
+
+    @classmethod
+    async def wrap(
+        cls,
+        transport_stream: AnyByteStream,
+        *,
+        server_side: bool | None = None,
+        hostname: str | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        standard_compatible: bool = True,
+    ) -> TLSStream:
+        """
+        Wrap an existing stream with Transport Layer Security.
+
+        This performs a TLS handshake with the peer.
+
+        :param transport_stream: a bytes-transporting stream to wrap
+        :param server_side: ``True`` if this is the server side of the connection,
+            ``False`` if this is the client side (if omitted, will be set to ``False``
+            if ``hostname`` has been provided, ``False`` otherwise). Used only to create
+            a default context when an explicit context has not been provided.
+        :param hostname: host name of the peer (if host name checking is desired)
+        :param ssl_context: the SSLContext object to use (if not provided, a secure
+            default will be created)
+        :param standard_compatible: if ``False``, skip the closing handshake when
+            closing the connection, and don't raise an exception if the peer does the
+            same
+        :raises ~ssl.SSLError: if the TLS handshake fails
+
+        """
+        if server_side is None:
+            server_side = not hostname
+
+        if not ssl_context:
+            purpose = (
+                ssl.Purpose.CLIENT_AUTH if server_side else ssl.Purpose.SERVER_AUTH
+            )
+            ssl_context = ssl.create_default_context(purpose)
+
+            # Re-enable detection of unexpected EOFs if it was disabled by Python
+            if hasattr(ssl, "OP_IGNORE_UNEXPECTED_EOF"):
+                ssl_context.options &= ~ssl.OP_IGNORE_UNEXPECTED_EOF
+
+        bio_in = ssl.MemoryBIO()
+        bio_out = ssl.MemoryBIO()
+
+        # Resolve international host names using IDNA 2008.
+        # Otherwise wrap_bio() would resolve them with IDNA 2003.
+        if hostname is not None:
+            from .._core._sockets import idna2008_resolve
+
+            server_hostname: bytes | None = idna2008_resolve(hostname)
+        else:
+            server_hostname = None
+
+        # External SSLContext implementations may do blocking I/O in wrap_bio(),
+        # but the standard library implementation won't
+        if type(ssl_context) is ssl.SSLContext:
+            ssl_object = ssl_context.wrap_bio(
+                bio_in,
+                bio_out,
+                server_side=server_side,
+                server_hostname=server_hostname,
+            )
+        else:
+            ssl_object = await to_thread.run_sync(
+                ssl_context.wrap_bio,
+                bio_in,
+                bio_out,
+                server_side,
+                server_hostname,
+                None,
+            )
+
+        wrapper = cls(
+            transport_stream=transport_stream,
+            standard_compatible=standard_compatible,
+            _ssl_object=ssl_object,
+            _read_bio=bio_in,
+            _write_bio=bio_out,
+        )
+        await wrapper._call_sslobject_method(ssl_object.do_handshake)
+        return wrapper
+
+    async def _call_sslobject_method(
+        self, func: Callable[[Unpack[PosArgsT]], T_Retval], *args: Unpack[PosArgsT]
+    ) -> T_Retval:
+        while True:
+            try:
+                result = func(*args)
+            except ssl.SSLWantReadError:
+                try:
+                    # Flush any pending writes first
+                    if self._write_bio.pending:
+                        await self.transport_stream.send(self._write_bio.read())
+
+                    data = await self.transport_stream.receive()
+                except EndOfStream:
+                    self._read_bio.write_eof()
+                except OSError as exc:
+                    self._read_bio.write_eof()
+                    self._write_bio.write_eof()
+                    raise BrokenResourceError from exc
+                else:
+                    self._read_bio.write(data)
+            except ssl.SSLWantWriteError:
+                await self.transport_stream.send(self._write_bio.read())
+            except ssl.SSLSyscallError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
+                raise BrokenResourceError from exc
+            except ssl.SSLError as exc:
+                self._read_bio.write_eof()
+                self._write_bio.write_eof()
+                if isinstance(exc, ssl.SSLEOFError) or (
+                    exc.strerror and "UNEXPECTED_EOF_WHILE_READING" in exc.strerror
+                ):
+                    if self.standard_compatible:
+                        raise BrokenResourceError from exc
+                    else:
+                        raise EndOfStream from None
+
+                raise
+            else:
+                # Flush any pending writes first
+                if self._write_bio.pending:
+                    await self.transport_stream.send(self._write_bio.read())
+
+                return result
+
+    async def unwrap(self) -> tuple[AnyByteStream, bytes]:
+        """
+        Does the TLS closing handshake.
+
+        :return: a tuple of (wrapped byte stream, bytes left in the read buffer)
+
+        """
+        await self._call_sslobject_method(self._ssl_object.unwrap)
+        self._read_bio.write_eof()
+        self._write_bio.write_eof()
+        return self.transport_stream, self._read_bio.read()
+
+    async def aclose(self) -> None:
+        if self.standard_compatible:
+            try:
+                await self.unwrap()
+            except BaseException:
+                await aclose_forcefully(self.transport_stream)
+                raise
+
+        await self.transport_stream.aclose()
+
+    async def receive(self, max_bytes: int = 65536) -> bytes:
+        if max_bytes < 1:
+            raise ValueError("max_bytes must be a positive integer")
+
+        data = await self._call_sslobject_method(self._ssl_object.read, max_bytes)
+        if not data:
+            raise EndOfStream
+
+        return data
+
+    async def send(self, item: bytes) -> None:
+        await self._call_sslobject_method(self._ssl_object.write, item)
+
+    async def send_eof(self) -> None:
+        tls_version = self.extra(TLSAttribute.tls_version)
+        match = re.match(r"TLSv(\d+)(?:\.(\d+))?", tls_version)
+        if match:
+            major, minor = int(match.group(1)), int(match.group(2) or 0)
+            if (major, minor) < (1, 3):
+                raise NotImplementedError(
+                    f"send_eof() requires at least TLSv1.3; current "
+                    f"session uses {tls_version}"
+                )
+
+        raise NotImplementedError(
+            "send_eof() has not yet been implemented for TLS streams"
+        )
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            **self.transport_stream.extra_attributes,
+            TLSAttribute.alpn_protocol: self._ssl_object.selected_alpn_protocol,
+            TLSAttribute.channel_binding_tls_unique: (
+                self._ssl_object.get_channel_binding
+            ),
+            TLSAttribute.cipher: self._ssl_object.cipher,
+            TLSAttribute.peer_certificate: lambda: self._ssl_object.getpeercert(False),
+            TLSAttribute.peer_certificate_binary: lambda: self._ssl_object.getpeercert(
+                True
+            ),
+            TLSAttribute.server_side: lambda: self._ssl_object.server_side,
+            TLSAttribute.shared_ciphers: lambda: (
+                self._ssl_object.shared_ciphers()
+                if self._ssl_object.server_side
+                else None
+            ),
+            TLSAttribute.standard_compatible: lambda: self.standard_compatible,
+            TLSAttribute.ssl_object: lambda: self._ssl_object,
+            TLSAttribute.tls_version: self._ssl_object.version,
+        }
+
+
+@dataclass(eq=False)
+class TLSListener(Listener[TLSStream]):
+    """
+    A convenience listener that wraps another listener and auto-negotiates a TLS session
+    on every accepted connection.
+
+    If the TLS handshake times out or raises an exception,
+    :meth:`handle_handshake_error` is called to do whatever post-mortem processing is
+    deemed necessary.
+
+    Supports only the :attr:`~TLSAttribute.standard_compatible` extra attribute.
+
+    :param Listener listener: the listener to wrap
+    :param ssl_context: the SSL context object
+    :param standard_compatible: a flag passed through to :meth:`TLSStream.wrap`
+    :param handshake_timeout: time limit for the TLS handshake
+        (passed to :func:`~anyio.fail_after`)
+    """
+
+    listener: Listener[Any]
+    ssl_context: ssl.SSLContext
+    standard_compatible: bool = True
+    handshake_timeout: float = 30
+
+    @staticmethod
+    async def handle_handshake_error(exc: BaseException, stream: AnyByteStream) -> None:
+        """
+        Handle an exception raised during the TLS handshake.
+
+        This method does 3 things:
+
+        #. Forcefully closes the original stream
+        #. Logs the exception (unless it was a cancellation exception) using the
+           ``anyio.streams.tls`` logger
+        #. Reraises the exception if it was a base exception or a cancellation exception
+
+        :param exc: the exception
+        :param stream: the original stream
+
+        """
+        await aclose_forcefully(stream)
+
+        # Log all except cancellation exceptions
+        if not isinstance(exc, get_cancelled_exc_class()):
+            # CPython (as of 3.11.5) returns incorrect `sys.exc_info()` here when using
+            # any asyncio implementation, so we explicitly pass the exception to log
+            # (https://github.com/python/cpython/issues/108668). Trio does not have this
+            # issue because it works around the CPython bug.
+            logging.getLogger(__name__).exception(
+                "Error during TLS handshake", exc_info=exc
+            )
+
+        # Only reraise base exceptions and cancellation exceptions
+        if not isinstance(exc, Exception) or isinstance(exc, get_cancelled_exc_class()):
+            raise  # noqa: PLE0704
+
+    async def serve(
+        self,
+        handler: Callable[[TLSStream], Any],
+        task_group: TaskGroup | None = None,
+    ) -> None:
+        @wraps(handler)
+        async def handler_wrapper(stream: AnyByteStream) -> None:
+            from .. import fail_after
+
+            try:
+                with fail_after(self.handshake_timeout):
+                    wrapped_stream = await TLSStream.wrap(
+                        stream,
+                        ssl_context=self.ssl_context,
+                        standard_compatible=self.standard_compatible,
+                    )
+            except BaseException as exc:
+                await self.handle_handshake_error(exc, stream)
+            else:
+                await handler(wrapped_stream)
+
+        await self.listener.serve(handler_wrapper, task_group)
+
+    async def aclose(self) -> None:
+        await self.listener.aclose()
+
+    @property
+    def extra_attributes(self) -> Mapping[Any, Callable[[], Any]]:
+        return {
+            TLSAttribute.standard_compatible: lambda: self.standard_compatible,
+        }
+
+
+class TLSConnectable(ByteStreamConnectable):
+    """
+    Wraps another connectable and does TLS negotiation after a successful connection.
+
+    :param connectable: the connectable to wrap
+    :param hostname: host name of the server (if host name checking is desired)
+    :param ssl_context: the SSLContext object to use (if not provided, a secure default
+        will be created)
+    :param standard_compatible: if ``False``, skip the closing handshake when closing
+        the connection, and don't raise an exception if the server does the same
+    """
+
+    def __init__(
+        self,
+        connectable: AnyByteStreamConnectable,
+        *,
+        hostname: str | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        standard_compatible: bool = True,
+    ) -> None:
+        self.connectable = connectable
+        self.ssl_context: SSLContext = ssl_context or ssl.create_default_context(
+            ssl.Purpose.SERVER_AUTH
+        )
+        if not isinstance(self.ssl_context, ssl.SSLContext):
+            raise TypeError(
+                "ssl_context must be an instance of ssl.SSLContext, not "
+                f"{type(self.ssl_context).__name__}"
+            )
+        self.hostname = hostname
+        self.standard_compatible = standard_compatible
+
+    @override
+    async def connect(self) -> TLSStream:
+        stream = await self.connectable.connect()
+        try:
+            return await TLSStream.wrap(
+                stream,
+                hostname=self.hostname,
+                ssl_context=self.ssl_context,
+                standard_compatible=self.standard_compatible,
+            )
+        except BaseException:
+            await aclose_forcefully(stream)
+            raise
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_interpreter.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_interpreter.py
new file mode 100644
index 0000000000000000000000000000000000000000..54ef4a8b8c58db9ea05e4188cf6d7899c8ff8c72
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_interpreter.py
@@ -0,0 +1,246 @@
+from __future__ import annotations
+
+__all__ = (
+    "current_default_interpreter_limiter",
+    "run_sync",
+)
+
+import atexit
+import os
+import sys
+from collections import deque
+from collections.abc import Callable
+from typing import Any, Final, TypeVar
+
+from . import current_time, to_thread
+from ._core._exceptions import BrokenWorkerInterpreter
+from ._core._synchronization import CapacityLimiter
+from .lowlevel import RunVar
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+if sys.version_info >= (3, 14):
+    from concurrent.interpreters import ExecutionFailed, create
+
+    def _interp_call(
+        func: Callable[..., Any], args: tuple[Any, ...]
+    ) -> tuple[Any, bool]:
+        try:
+            retval = func(*args)
+        except BaseException as exc:
+            return exc, True
+        else:
+            return retval, False
+
+    class _Worker:
+        last_used: float = 0
+
+        def __init__(self) -> None:
+            self._interpreter = create()
+
+        def destroy(self) -> None:
+            self._interpreter.close()
+
+        def call(
+            self,
+            func: Callable[..., T_Retval],
+            args: tuple[Any, ...],
+        ) -> T_Retval:
+            try:
+                res, is_exception = self._interpreter.call(_interp_call, func, args)
+            except ExecutionFailed as exc:
+                raise BrokenWorkerInterpreter(exc.excinfo) from exc
+
+            if is_exception:
+                raise res
+
+            return res
+elif sys.version_info >= (3, 13):
+    import _interpqueues
+    import _interpreters
+
+    UNBOUND: Final = 2  # I have no clue how this works, but it was used in the stdlib
+    FMT_UNPICKLED: Final = 0
+    FMT_PICKLED: Final = 1
+    QUEUE_PICKLE_ARGS: Final = (FMT_PICKLED, UNBOUND)
+    QUEUE_UNPICKLE_ARGS: Final = (FMT_UNPICKLED, UNBOUND)
+
+    _run_func = compile(
+        """
+import _interpqueues
+from _interpreters import NotShareableError
+from pickle import loads, dumps, HIGHEST_PROTOCOL
+
+QUEUE_PICKLE_ARGS = (1, 2)
+QUEUE_UNPICKLE_ARGS = (0, 2)
+
+item = _interpqueues.get(queue_id)[0]
+try:
+    func, args = loads(item)
+    retval = func(*args)
+except BaseException as exc:
+    is_exception = True
+    retval = exc
+else:
+    is_exception = False
+
+try:
+    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_UNPICKLE_ARGS)
+except NotShareableError:
+    retval = dumps(retval, HIGHEST_PROTOCOL)
+    _interpqueues.put(queue_id, (retval, is_exception), *QUEUE_PICKLE_ARGS)
+    """,
+        "<string>",
+        "exec",
+    )
+
+    class _Worker:
+        last_used: float = 0
+
+        def __init__(self) -> None:
+            self._interpreter_id = _interpreters.create()
+            self._queue_id = _interpqueues.create(1, *QUEUE_UNPICKLE_ARGS)
+            _interpreters.set___main___attrs(
+                self._interpreter_id, {"queue_id": self._queue_id}
+            )
+
+        def destroy(self) -> None:
+            _interpqueues.destroy(self._queue_id)
+            _interpreters.destroy(self._interpreter_id)
+
+        def call(
+            self,
+            func: Callable[..., T_Retval],
+            args: tuple[Any, ...],
+        ) -> T_Retval:
+            import pickle
+
+            item = pickle.dumps((func, args), pickle.HIGHEST_PROTOCOL)
+            _interpqueues.put(self._queue_id, item, *QUEUE_PICKLE_ARGS)
+            exc_info = _interpreters.exec(self._interpreter_id, _run_func)
+            if exc_info:
+                raise BrokenWorkerInterpreter(exc_info)
+
+            res = _interpqueues.get(self._queue_id)
+            (res, is_exception), fmt = res[:2]
+            if fmt == FMT_PICKLED:
+                res = pickle.loads(res)
+
+            if is_exception:
+                raise res
+
+            return res
+else:
+
+    class _Worker:
+        last_used: float = 0
+
+        def __init__(self) -> None:
+            raise RuntimeError("subinterpreters require at least Python 3.13")
+
+        def call(
+            self,
+            func: Callable[..., T_Retval],
+            args: tuple[Any, ...],
+        ) -> T_Retval:
+            raise NotImplementedError
+
+        def destroy(self) -> None:
+            pass
+
+
+DEFAULT_CPU_COUNT: Final = 8  # this is just an arbitrarily selected value
+MAX_WORKER_IDLE_TIME = (
+    30  # seconds a subinterpreter can be idle before becoming eligible for pruning
+)
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+_idle_workers = RunVar[deque[_Worker]]("_available_workers")
+_default_interpreter_limiter = RunVar[CapacityLimiter]("_default_interpreter_limiter")
+
+
+def _stop_workers(workers: deque[_Worker]) -> None:
+    for worker in workers:
+        worker.destroy()
+
+    workers.clear()
+
+
+async def run_sync(
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
+    limiter: CapacityLimiter | None = None,
+) -> T_Retval:
+    """
+    Call the given function with the given arguments in a subinterpreter.
+
+    .. warning:: On Python 3.13, the :mod:`concurrent.interpreters` module was not yet
+        available, so the code path for that Python version relies on an undocumented,
+        private API. As such, it is recommended to not rely on this function for anything
+        mission-critical on Python 3.13.
+
+    :param func: a callable
+    :param args: the positional arguments for the callable
+    :param limiter: capacity limiter to use to limit the total number of subinterpreters
+        running (if omitted, the default limiter is used)
+    :return: the result of the call
+    :raises BrokenWorkerInterpreter: if there's an internal error in a subinterpreter
+
+    """
+    if limiter is None:
+        limiter = current_default_interpreter_limiter()
+
+    try:
+        idle_workers = _idle_workers.get()
+    except LookupError:
+        idle_workers = deque()
+        _idle_workers.set(idle_workers)
+        atexit.register(_stop_workers, idle_workers)
+
+    async with limiter:
+        try:
+            worker = idle_workers.pop()
+        except IndexError:
+            worker = _Worker()
+
+    try:
+        return await to_thread.run_sync(
+            worker.call,
+            func,
+            args,
+            limiter=limiter,
+        )
+    finally:
+        # Prune workers that have been idle for too long
+        now = current_time()
+        while idle_workers:
+            if now - idle_workers[0].last_used <= MAX_WORKER_IDLE_TIME:
+                break
+
+            await to_thread.run_sync(idle_workers.popleft().destroy, limiter=limiter)
+
+        worker.last_used = current_time()
+        idle_workers.append(worker)
+
+
+def current_default_interpreter_limiter() -> CapacityLimiter:
+    """
+    Return the capacity limiter used by default to limit the number of concurrently
+    running subinterpreters.
+
+    Defaults to the number of CPU cores.
+
+    :return: a capacity limiter object
+
+    """
+    try:
+        return _default_interpreter_limiter.get()
+    except LookupError:
+        limiter = CapacityLimiter(os.cpu_count() or DEFAULT_CPU_COUNT)
+        _default_interpreter_limiter.set(limiter)
+        return limiter
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_process.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_process.py
new file mode 100644
index 0000000000000000000000000000000000000000..584128ec3b2d4bbd0a9634fc7f2f39caf1fe968d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_process.py
@@ -0,0 +1,269 @@
+from __future__ import annotations
+
+__all__ = (
+    "current_default_process_limiter",
+    "process_worker",
+    "run_sync",
+)
+
+import os
+import pickle
+import runpy
+import subprocess
+import sys
+from collections import deque
+from collections.abc import Callable
+from types import ModuleType
+from typing import TypeVar, cast
+
+from ._core._eventloop import current_time, get_async_backend, get_cancelled_exc_class
+from ._core._exceptions import BrokenWorkerProcess
+from ._core._subprocesses import open_process
+from ._core._synchronization import CapacityLimiter
+from ._core._tasks import CancelScope, fail_after
+from .abc import ByteReceiveStream, ByteSendStream, Process
+from .lowlevel import RunVar, checkpoint_if_cancelled
+from .streams.buffered import BufferedByteReceiveStream
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+WORKER_MAX_IDLE_TIME = 300  # 5 minutes
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+_process_pool_workers: RunVar[set[Process]] = RunVar("_process_pool_workers")
+_process_pool_idle_workers: RunVar[deque[tuple[Process, float]]] = RunVar(
+    "_process_pool_idle_workers"
+)
+_default_process_limiter: RunVar[CapacityLimiter] = RunVar("_default_process_limiter")
+
+
+async def run_sync(  # type: ignore[return]
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
+    cancellable: bool = False,
+    limiter: CapacityLimiter | None = None,
+) -> T_Retval:
+    """
+    Call the given function with the given arguments in a worker process.
+
+    If the ``cancellable`` option is enabled and the task waiting for its completion is
+    cancelled, the worker process running it will be abruptly terminated using SIGKILL
+    (or ``terminateProcess()`` on Windows).
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :param cancellable: ``True`` to allow cancellation of the operation while it's
+        running
+    :param limiter: capacity limiter to use to limit the total amount of processes
+        running (if omitted, the default limiter is used)
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+    :return: an awaitable that yields the return value of the function.
+
+    """
+
+    async def send_raw_command(pickled_cmd: bytes) -> object:
+        try:
+            await stdin.send(pickled_cmd)
+            response = await buffered.receive_until(b"\n", 50)
+            status, length = response.split(b" ")
+            if status not in (b"RETURN", b"EXCEPTION"):
+                raise RuntimeError(
+                    f"Worker process returned unexpected response: {response!r}"
+                )
+
+            pickled_response = await buffered.receive_exactly(int(length))
+        except BaseException as exc:
+            workers.discard(process)
+            try:
+                process.kill()
+                with CancelScope(shield=True):
+                    await process.aclose()
+            except ProcessLookupError:
+                pass
+
+            if isinstance(exc, get_cancelled_exc_class()):
+                raise
+            else:
+                raise BrokenWorkerProcess from exc
+
+        retval = pickle.loads(pickled_response)
+        if status == b"EXCEPTION":
+            assert isinstance(retval, BaseException)
+            raise retval
+        else:
+            return retval
+
+    # First pickle the request before trying to reserve a worker process
+    await checkpoint_if_cancelled()
+    request = pickle.dumps(("run", func, args), protocol=pickle.HIGHEST_PROTOCOL)
+
+    # If this is the first run in this event loop thread, set up the necessary variables
+    try:
+        workers = _process_pool_workers.get()
+        idle_workers = _process_pool_idle_workers.get()
+    except LookupError:
+        workers = set()
+        idle_workers = deque()
+        _process_pool_workers.set(workers)
+        _process_pool_idle_workers.set(idle_workers)
+        get_async_backend().setup_process_pool_exit_at_shutdown(workers)
+
+    async with limiter or current_default_process_limiter():
+        # Pop processes from the pool (starting from the most recently used) until we
+        # find one that hasn't exited yet
+        process: Process
+        while idle_workers:
+            process, _idle_since = idle_workers.pop()
+            if process.returncode is None:
+                stdin = cast(ByteSendStream, process.stdin)
+                buffered = BufferedByteReceiveStream(
+                    cast(ByteReceiveStream, process.stdout)
+                )
+
+                # Prune any other workers that have been idle for WORKER_MAX_IDLE_TIME
+                # seconds or longer
+                now = current_time()
+                killed_processes: list[Process] = []
+                while idle_workers:
+                    if now - idle_workers[0][1] < WORKER_MAX_IDLE_TIME:
+                        break
+
+                    process_to_kill, _idle_since = idle_workers.popleft()
+                    process_to_kill.kill()
+                    workers.remove(process_to_kill)
+                    killed_processes.append(process_to_kill)
+
+                with CancelScope(shield=True):
+                    for killed_process in killed_processes:
+                        await killed_process.aclose()
+
+                break
+
+            workers.remove(process)
+        else:
+            command = [sys.executable, "-u", "-m", __name__]
+            process = await open_process(
+                command, stdin=subprocess.PIPE, stdout=subprocess.PIPE
+            )
+            try:
+                stdin = cast(ByteSendStream, process.stdin)
+                buffered = BufferedByteReceiveStream(
+                    cast(ByteReceiveStream, process.stdout)
+                )
+                with fail_after(20):
+                    message = await buffered.receive(6)
+
+                if message != b"READY\n":
+                    raise BrokenWorkerProcess(
+                        f"Worker process returned unexpected response: {message!r}"
+                    )
+
+                main_module_path = getattr(sys.modules["__main__"], "__file__", None)
+                pickled = pickle.dumps(
+                    ("init", sys.path, main_module_path),
+                    protocol=pickle.HIGHEST_PROTOCOL,
+                )
+                await send_raw_command(pickled)
+            except (BrokenWorkerProcess, get_cancelled_exc_class()):
+                raise
+            except BaseException as exc:
+                process.kill()
+                raise BrokenWorkerProcess(
+                    "Error during worker process initialization"
+                ) from exc
+
+            workers.add(process)
+
+        with CancelScope(shield=not cancellable):
+            try:
+                return cast(T_Retval, await send_raw_command(request))
+            finally:
+                if process in workers:
+                    idle_workers.append((process, current_time()))
+
+
+def current_default_process_limiter() -> CapacityLimiter:
+    """
+    Return the capacity limiter that is used by default to limit the number of worker
+    processes.
+
+    :return: a capacity limiter object
+
+    """
+    try:
+        return _default_process_limiter.get()
+    except LookupError:
+        limiter = CapacityLimiter(os.cpu_count() or 2)
+        _default_process_limiter.set(limiter)
+        return limiter
+
+
+def process_worker() -> None:
+    # Redirect standard streams to os.devnull so that user code won't interfere with the
+    # parent-worker communication
+    stdin = sys.stdin
+    stdout = sys.stdout
+    sys.stdin = open(os.devnull)
+    sys.stdout = open(os.devnull, "w")
+    sys.stderr = open(os.devnull, "w")
+
+    stdout.buffer.write(b"READY\n")
+    while True:
+        retval = exception = None
+        try:
+            command, *args = pickle.load(stdin.buffer)
+        except EOFError:
+            return
+        except BaseException as exc:
+            exception = exc
+        else:
+            if command == "run":
+                func, args = args
+                try:
+                    retval = func(*args)
+                except BaseException as exc:
+                    exception = exc
+            elif command == "init":
+                main_module_path: str | None
+                sys.path, main_module_path = args
+                del sys.modules["__main__"]
+                if main_module_path and os.path.isfile(main_module_path):
+                    # Load the parent's main module but as __mp_main__ instead of
+                    # __main__ (like multiprocessing does) to avoid infinite recursion
+                    try:
+                        main = ModuleType("__mp_main__")
+                        main_content = runpy.run_path(
+                            main_module_path, run_name="__mp_main__"
+                        )
+                        main.__dict__.update(main_content)
+                        sys.modules["__main__"] = sys.modules["__mp_main__"] = main
+                    except BaseException as exc:
+                        exception = exc
+        try:
+            if exception is not None:
+                status = b"EXCEPTION"
+                pickled = pickle.dumps(exception, pickle.HIGHEST_PROTOCOL)
+            else:
+                status = b"RETURN"
+                pickled = pickle.dumps(retval, pickle.HIGHEST_PROTOCOL)
+        except BaseException as exc:
+            exception = exc
+            status = b"EXCEPTION"
+            pickled = pickle.dumps(exc, pickle.HIGHEST_PROTOCOL)
+
+        stdout.buffer.write(b"%s %d\n" % (status, len(pickled)))
+        stdout.buffer.write(pickled)
+
+        # Respect SIGTERM
+        if isinstance(exception, SystemExit):
+            raise exception
+
+
+if __name__ == "__main__":
+    process_worker()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_thread.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_thread.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cdb7253e3c0a4f99ad2f893d31cc32f8fbda298
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/anyio/to_thread.py
@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+__all__ = (
+    "current_default_thread_limiter",
+    "run_sync",
+)
+
+import sys
+from collections.abc import Callable
+from typing import TYPE_CHECKING, TypeVar
+from warnings import warn
+
+from ._core._eventloop import get_async_backend
+
+if TYPE_CHECKING:
+    from ._core._synchronization import CapacityLimiter
+
+if sys.version_info >= (3, 11):
+    from typing import TypeVarTuple, Unpack
+else:
+    from typing_extensions import TypeVarTuple, Unpack
+
+T_Retval = TypeVar("T_Retval")
+PosArgsT = TypeVarTuple("PosArgsT")
+
+
+async def run_sync(
+    func: Callable[[Unpack[PosArgsT]], T_Retval],
+    *args: Unpack[PosArgsT],
+    abandon_on_cancel: bool = False,
+    cancellable: bool | None = None,
+    limiter: CapacityLimiter | None = None,
+) -> T_Retval:
+    """
+    Call the given function with the given arguments in a worker thread.
+
+    If the ``abandon_on_cancel`` option is enabled and the task waiting for its
+    completion is cancelled, the thread will still run its course but its
+    return value (or any raised exception) will be ignored.
+
+    :param func: a callable
+    :param args: positional arguments for the callable
+    :param abandon_on_cancel: ``True`` to abandon the thread (leaving it to run
+        unchecked on own) if the host task is cancelled, ``False`` to ignore
+        cancellations in the host task until the operation has completed in the worker
+        thread
+    :param cancellable: deprecated alias of ``abandon_on_cancel``; will override
+        ``abandon_on_cancel`` if both parameters are passed
+    :param limiter: capacity limiter to use to limit the total amount of threads running
+        (if omitted, the default limiter is used)
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+    :return: an awaitable that yields the return value of the function.
+
+    """
+    if cancellable is not None:
+        abandon_on_cancel = cancellable
+        warn(
+            "The `cancellable=` keyword argument to `anyio.to_thread.run_sync` is "
+            "deprecated since AnyIO 4.1.0; use `abandon_on_cancel=` instead",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
+    return await get_async_backend().run_sync_in_worker_thread(
+        func, args, abandon_on_cancel=abandon_on_cancel, limiter=limiter
+    )
+
+
+def current_default_thread_limiter() -> CapacityLimiter:
+    """
+    Return the capacity limiter that is used by default to limit the number of
+    concurrent threads.
+
+    :return: a capacity limiter object
+    :raises NoEventLoopError: if no supported asynchronous event loop is running in the
+        current thread
+
+    """
+    return get_async_backend().current_default_thread_limiter()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..7b785308a746c2f777c0d53a6c0f47344d74ecce
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/METADATA
@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: click
+Version: 8.5.0
+Summary: Composable command line interface toolkit
+Maintainer-email: Pallets <contact@palletsprojects.com>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-Expression: BSD-3-Clause
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Typing :: Typed
+License-File: LICENSE.txt
+Project-URL: Changes, https://click.palletsprojects.com/page/changes/
+Project-URL: Chat, https://discord.gg/pallets
+Project-URL: Documentation, https://click.palletsprojects.com/
+Project-URL: Donate, https://palletsprojects.com/donate
+Project-URL: Source, https://github.com/pallets/click/
+
+<div align="center"><img src="https://raw.githubusercontent.com/pallets/click/refs/heads/stable/docs/_static/click-name.svg" alt="" height="150"></div>
+
+# Click
+
+Click is a Python package for creating beautiful command line interfaces
+in a composable way with as little code as necessary. It's the "Command
+Line Interface Creation Kit". It's highly configurable but comes with
+sensible defaults out of the box.
+
+It aims to make the process of writing command line tools quick and fun
+while also preventing any frustration caused by the inability to
+implement an intended CLI API.
+
+Click in three points:
+
+-   Arbitrary nesting of commands
+-   Automatic help page generation
+-   Supports lazy loading of subcommands at runtime
+
+
+## A Simple Example
+
+```python
+import click
+
+@click.command()
+@click.option("--count", default=1, help="Number of greetings.")
+@click.option("--name", prompt="Your name", help="The person to greet.")
+def hello(count, name):
+    """Simple program that greets NAME for a total of COUNT times."""
+    for _ in range(count):
+        click.echo(f"Hello, {name}!")
+
+if __name__ == '__main__':
+    hello()
+```
+
+```
+$ python hello.py --count=3
+Your name: Click
+Hello, Click!
+Hello, Click!
+Hello, Click!
+```
+
+
+## Donate
+
+The Pallets organization develops and supports Click and other popular
+packages. In order to grow the community of contributors and users, and
+allow the maintainers to devote more time to the projects, [please
+donate today][].
+
+[please donate today]: https://palletsprojects.com/donate
+
+## Contributing
+
+See our [detailed contributing documentation][contrib] for many ways to
+contribute, including reporting issues, requesting features, asking or answering
+questions, and making PRs.
+
+[contrib]: https://palletsprojects.com/contributing/
+
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..e35a35e22d7203d6a421736c15f6de037f9edfc1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/RECORD
@@ -0,0 +1,40 @@
+click-8.5.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+click-8.5.0.dist-info/METADATA,sha256=6HvOC9GU3nDfuOcI4KawSDAJ8lYRgE6vh7_rY-bCBQE,2567
+click-8.5.0.dist-info/RECORD,,
+click-8.5.0.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+click-8.5.0.dist-info/licenses/LICENSE.txt,sha256=morRBqOU6FO_4h9C9OctWSgZoigF2ZG18ydQKSkrZY0,1475
+click/__init__.py,sha256=Wr_FTTfUfMeIt-egXpUUeH-MWgt9tCnQ8k10isiZZMo,5145
+click/__pycache__/__init__.cpython-311.pyc,,
+click/__pycache__/_compat.cpython-311.pyc,,
+click/__pycache__/_termui_impl.cpython-311.pyc,,
+click/__pycache__/_textwrap.cpython-311.pyc,,
+click/__pycache__/_utils.cpython-311.pyc,,
+click/__pycache__/_winconsole.cpython-311.pyc,,
+click/__pycache__/core.cpython-311.pyc,,
+click/__pycache__/decorators.cpython-311.pyc,,
+click/__pycache__/exceptions.cpython-311.pyc,,
+click/__pycache__/formatting.cpython-311.pyc,,
+click/__pycache__/globals.cpython-311.pyc,,
+click/__pycache__/parser.cpython-311.pyc,,
+click/__pycache__/shell_completion.cpython-311.pyc,,
+click/__pycache__/termui.cpython-311.pyc,,
+click/__pycache__/testing.cpython-311.pyc,,
+click/__pycache__/types.cpython-311.pyc,,
+click/__pycache__/utils.cpython-311.pyc,,
+click/_compat.py,sha256=jbHaKWXPPl3GbGxTgzy8YT6hzSRAudDraqg2DrRtSRM,17939
+click/_termui_impl.py,sha256=iLl9m3pblHsQoW2KsmmDe8hMflXCi6cupfL7M5ESM2o,32805
+click/_textwrap.py,sha256=7Z0N7Vmn-66TNSTUwp6OXJbcUXRmYET9h9c2ucD8oQQ,6270
+click/_utils.py,sha256=eCZCtwJtsYD5QYkkNWJ8MY_8ABIjy8MczgMMyVY32rQ,996
+click/_winconsole.py,sha256=KSxfNbMlYRa6GOJuCLgsg2Pb3dVkgJNPqLJPae-Pa10,8543
+click/core.py,sha256=TGWmE8HEB9zpB6ThI7Es7F_g9iCIqLn4b6vUtgxLbXg,147845
+click/decorators.py,sha256=FgaTV2FWkfzfyceUu1FfYAnrNarW96dsAXvc4G2ujVU,21680
+click/exceptions.py,sha256=HvSY34G4auj_bYRR8-T8CU8Jwq_1-OcsRU4ezfozeEk,11862
+click/formatting.py,sha256=8SW2KGkvjfz9Q1NbeojMHuZBN0cfnQJDs4mqDP6oXms,10444
+click/globals.py,sha256=gM-Nh6A4M0HB_SgkaF5M4ncGGMDHc_flHXu9_oh4GEU,1923
+click/parser.py,sha256=oJ-fU_3mvxugIuNtHaCATZ56lgEmHRggjJiSqEgYrjA,19052
+click/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+click/shell_completion.py,sha256=GFIvdd3_5lXpQ5eNGVMlXER4QoZ9P9Z_vcFUPT332gk,26172
+click/termui.py,sha256=jsgCK45FKPhz7EExlKXRYU6W2lC2xKcfYmCzJnYqfpw,35370
+click/testing.py,sha256=dvTmSbxTAA1mfIwN7_FZGXD6A0sPCFogcWWDmyMBAZo,27584
+click/types.py,sha256=HpiJBKen9oq61jDH-5wDikNF-i5nAcl2puUfEL37Ut0,46842
+click/utils.py,sha256=9D1XQ9wHJA5hL-76CmnSsWl7aQAUn4-An_zZfstILb8,21483
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..d8b9936dad9ab2513fa6979f411560d3b6b57e37
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: flit 3.12.0
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/licenses/LICENSE.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/licenses/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..d12a849186982399c537c5b9a8fd77bf2edd5eab
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click-8.5.0.dist-info/licenses/LICENSE.txt
@@ -0,0 +1,28 @@
+Copyright 2014 Pallets
+
+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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a34ab023a658c1b38fe75e57781afd3380718638
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__init__.py
@@ -0,0 +1,144 @@
+"""
+Click is a simple Python module inspired by the stdlib optparse to make
+writing command line scripts fun. Unlike other modules, it's based
+around a simple API that does not come with too much magic and is
+composable.
+"""
+
+from __future__ import annotations
+
+from .core import Argument as Argument
+from .core import Command as Command
+from .core import CommandCollection as CommandCollection
+from .core import Context as Context
+from .core import Group as Group
+from .core import Option as Option
+from .core import Parameter as Parameter
+from .core import ParameterSource as ParameterSource
+from .decorators import argument as argument
+from .decorators import command as command
+from .decorators import confirmation_option as confirmation_option
+from .decorators import custom_version_option as custom_version_option
+from .decorators import group as group
+from .decorators import help_option as help_option
+from .decorators import make_pass_decorator as make_pass_decorator
+from .decorators import option as option
+from .decorators import pass_context as pass_context
+from .decorators import pass_obj as pass_obj
+from .decorators import password_option as password_option
+from .decorators import version_option as version_option
+from .exceptions import Abort as Abort
+from .exceptions import BadArgumentUsage as BadArgumentUsage
+from .exceptions import BadOptionUsage as BadOptionUsage
+from .exceptions import BadParameter as BadParameter
+from .exceptions import ClickException as ClickException
+from .exceptions import FileError as FileError
+from .exceptions import MissingParameter as MissingParameter
+from .exceptions import NoSuchCommand as NoSuchCommand
+from .exceptions import NoSuchOption as NoSuchOption
+from .exceptions import UsageError as UsageError
+from .formatting import HelpFormatter as HelpFormatter
+from .formatting import wrap_text as wrap_text
+from .globals import get_current_context as get_current_context
+from .termui import clear as clear
+from .termui import confirm as confirm
+from .termui import echo_via_pager as echo_via_pager
+from .termui import edit as edit
+from .termui import get_pager_file as get_pager_file
+from .termui import getchar as getchar
+from .termui import launch as launch
+from .termui import pause as pause
+from .termui import progressbar as progressbar
+from .termui import prompt as prompt
+from .termui import secho as secho
+from .termui import style as style
+from .termui import unstyle as unstyle
+from .types import BOOL as BOOL
+from .types import Choice as Choice
+from .types import DateTime as DateTime
+from .types import File as File
+from .types import FLOAT as FLOAT
+from .types import FloatRange as FloatRange
+from .types import INT as INT
+from .types import IntRange as IntRange
+from .types import ParamType as ParamType
+from .types import Path as Path
+from .types import STRING as STRING
+from .types import Tuple as Tuple
+from .types import UNPROCESSED as UNPROCESSED
+from .types import UUID as UUID
+from .utils import echo as echo
+from .utils import format_filename as format_filename
+from .utils import get_app_dir as get_app_dir
+from .utils import open_file as open_file
+
+
+def __getattr__(name: str) -> object:
+    import warnings
+
+    if name == "BaseCommand":
+        from .core import _BaseCommand
+
+        warnings.warn(
+            "'BaseCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Command' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _BaseCommand
+
+    if name == "MultiCommand":
+        from .core import _MultiCommand
+
+        warnings.warn(
+            "'MultiCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Group' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _MultiCommand
+
+    if name == "OptionParser":
+        from .parser import _OptionParser
+
+        warnings.warn(
+            "'OptionParser' is deprecated and will be removed in Click 9.0. The"
+            " old parser is available in 'optparse'.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _OptionParser
+
+    if name == "__version__":
+        import importlib.metadata
+
+        warnings.warn(
+            "The '__version__' attribute is deprecated and will be removed in"
+            " Click 9.1. Use feature detection or"
+            " 'importlib.metadata.version(\"click\")' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return importlib.metadata.version("click")
+
+    if name == "get_binary_stream":
+        from .utils import _get_binary_stream
+
+        warnings.warn(
+            "'get_binary_stream' is deprecated and will be removed in Click 9.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _get_binary_stream
+
+    if name == "get_text_stream":
+        from .utils import _get_text_stream
+
+        warnings.warn(
+            "'get_text_stream' is deprecated and will be removed in Click 9.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _get_text_stream
+
+    raise AttributeError(name)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..35aafc6b581e81a767fda0961742ea04b54562e3
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_compat.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_compat.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7e2ad37b8c2b976d31473333b7585a6c1a870546
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_compat.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_termui_impl.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_termui_impl.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..89ec9449cb0314ad0f39aa4f594ea3c1a771ff1e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_termui_impl.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_textwrap.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_textwrap.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d6e7e6e145d9af79c0115f5e5bb8a9342988ff1e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_textwrap.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbaf79511907450943131dac2243a0a33ff97bcc
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_winconsole.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_winconsole.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..559ff61ddfd7cec56f90be4937b058386b2b4c2c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/_winconsole.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/core.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/core.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..41940d1fe8c3a8017f597f3593cd09a3306dab32
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/core.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68702d0b3700602ad4d07f1751778100cf99bd33d119ac0bb89eeb43eecd7202
+size 159871
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/decorators.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/decorators.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ba0ce895822839f8c66dcf65655ad1ffb179b6b8
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/decorators.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0e9f4d3aa23648673a44a29742cfc07513887e03
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/formatting.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/formatting.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ffa051dba7ce4d751e714c45e60b53c12a83b38a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/formatting.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/globals.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/globals.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69f8144bc2dea45ae5d1cd31d064d17194368988
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/globals.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/parser.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/parser.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f1555c984a2904ecb11d46825829535ee00932ec
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/parser.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/shell_completion.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/shell_completion.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..660cd7981c042e81e90663caad6ed2ffa420265e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/shell_completion.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/termui.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/termui.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b17435a12c1aeb3d743c9943f4cabc0ebc8b37f5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/termui.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/testing.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/testing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..366e1e0a890aa2c8c53b7e6e0bb29a9e9058bd09
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/testing.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/types.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7191fb9e2a4aa9181fdf2357bd864b22175e094c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/types.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5cd12290e102b73a18ceaedfea005164d37782c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/__pycache__/utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_compat.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..8507a503abf9b5fcaf3285dc3999ae223c7608c8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_compat.py
@@ -0,0 +1,590 @@
+from __future__ import annotations
+
+import codecs
+import collections.abc as cabc
+import io
+import os
+import re
+import sys
+import typing as t
+from types import TracebackType
+from weakref import WeakKeyDictionary
+
+CYGWIN = sys.platform.startswith("cygwin")
+WIN = sys.platform.startswith("win")
+# One CSI escape sequence per the ECMA-48 grammar: parameter bytes (0x30-0x3F),
+# intermediate bytes (0x20-0x2F), then a final byte (0x40-0x7E). Broader than the
+# SGR codes Click emits, so foreign sequences (colon-delimited true-color, mouse
+# reporting) are stripped too.
+_ansi_re = re.compile(r"\033\[[0-?]*[ -/]*[@-~]")
+
+
+def _make_text_stream(
+    stream: t.BinaryIO,
+    encoding: str | None,
+    errors: str | None,
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if encoding is None:
+        encoding = get_best_encoding(stream)
+    if errors is None:
+        errors = "replace"
+    return _NonClosingTextIOWrapper(
+        stream,
+        encoding,
+        errors,
+        line_buffering=True,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def is_ascii_encoding(encoding: str) -> bool:
+    """Checks if a given encoding is ascii."""
+    try:
+        return codecs.lookup(encoding).name == "ascii"
+    except LookupError:
+        return False
+
+
+def get_best_encoding(stream: t.IO[t.Any]) -> str:
+    """Returns the default stream encoding if not found."""
+    rv = getattr(stream, "encoding", None) or sys.getdefaultencoding()
+    if is_ascii_encoding(rv):
+        return "utf-8"
+    return rv
+
+
+class _NonClosingTextIOWrapper(io.TextIOWrapper):
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        encoding: str | None,
+        errors: str | None,
+        force_readable: bool = False,
+        force_writable: bool = False,
+        **extra: t.Any,
+    ) -> None:
+        self._stream = stream = t.cast(
+            t.BinaryIO, _FixupStream(stream, force_readable, force_writable)
+        )
+        super().__init__(stream, encoding, errors, **extra)
+
+    def __del__(self) -> None:
+        try:
+            self.detach()
+        except Exception:
+            pass
+
+    def isatty(self) -> bool:
+        # https://bitbucket.org/pypy/pypy/issue/1803
+        return self._stream.isatty()
+
+
+class _FixupStream:
+    """The new io interface needs more from streams than streams
+    traditionally implement.  As such, this fix-up code is necessary in
+    some circumstances.
+
+    The forcing of readable and writable flags are there because some tools
+    put badly patched objects on sys (one such offender are certain version
+    of jupyter notebook).
+    """
+
+    def __init__(
+        self,
+        stream: t.BinaryIO,
+        force_readable: bool = False,
+        force_writable: bool = False,
+    ):
+        self._stream = stream
+        self._force_readable = force_readable
+        self._force_writable = force_writable
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._stream, name)
+
+    def read1(self, size: int) -> bytes:
+        f = getattr(self._stream, "read1", None)
+
+        if f is not None:
+            return t.cast(bytes, f(size))
+
+        return self._stream.read(size)
+
+    def readable(self) -> bool:
+        if self._force_readable:
+            return True
+        x = getattr(self._stream, "readable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.read(0)
+        except Exception:
+            return False
+        return True
+
+    def writable(self) -> bool:
+        if self._force_writable:
+            return True
+        x = getattr(self._stream, "writable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.write(b"")
+        except Exception:
+            try:
+                self._stream.write(b"")
+            except Exception:
+                return False
+        return True
+
+    def seekable(self) -> bool:
+        x = getattr(self._stream, "seekable", None)
+        if x is not None:
+            return t.cast(bool, x())
+        try:
+            self._stream.seek(self._stream.tell())
+        except Exception:
+            return False
+        return True
+
+
+def _is_binary_reader(stream: t.IO[t.Any], default: bool = False) -> bool:
+    try:
+        return isinstance(stream.read(0), bytes)
+    except Exception:
+        return default
+        # This happens in some cases where the stream was already
+        # closed.  In this case, we assume the default.
+
+
+def _is_binary_writer(stream: t.IO[t.Any], default: bool = False) -> bool:
+    try:
+        stream.write(b"")
+    except Exception:
+        try:
+            stream.write("")
+            return False
+        except Exception:
+            pass
+        return default
+    return True
+
+
+def _find_binary_reader(stream: t.IO[t.Any]) -> t.BinaryIO | None:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_reader(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_reader(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _find_binary_writer(stream: t.IO[t.Any]) -> t.BinaryIO | None:
+    # We need to figure out if the given stream is already binary.
+    # This can happen because the official docs recommend detaching
+    # the streams to get binary streams.  Some code might do this, so
+    # we need to deal with this case explicitly.
+    if _is_binary_writer(stream, False):
+        return t.cast(t.BinaryIO, stream)
+
+    buf = getattr(stream, "buffer", None)
+
+    # Same situation here; this time we assume that the buffer is
+    # actually binary in case it's closed.
+    if buf is not None and _is_binary_writer(buf, True):
+        return t.cast(t.BinaryIO, buf)
+
+    return None
+
+
+def _stream_is_misconfigured(stream: t.TextIO) -> bool:
+    """A stream is misconfigured if its encoding is ASCII."""
+    # If the stream does not have an encoding set, we assume it's set
+    # to ASCII.  This appears to happen in certain unittest
+    # environments.  It's not quite clear what the correct behavior is
+    # but this at least will force Click to recover somehow.
+    return is_ascii_encoding(getattr(stream, "encoding", None) or "ascii")
+
+
+def _is_compat_stream_attr(stream: t.TextIO, attr: str, value: str | None) -> bool:
+    """A stream attribute is compatible if it is equal to the
+    desired value or the desired value is unset and the attribute
+    has a value.
+    """
+    stream_value = getattr(stream, attr, None)
+    return stream_value == value or (value is None and stream_value is not None)
+
+
+def _is_compatible_text_stream(
+    stream: t.TextIO, encoding: str | None, errors: str | None
+) -> bool:
+    """Check if a stream's encoding and errors attributes are
+    compatible with the desired values.
+    """
+    return _is_compat_stream_attr(
+        stream, "encoding", encoding
+    ) and _is_compat_stream_attr(stream, "errors", errors)
+
+
+def _force_correct_text_stream(
+    text_stream: t.IO[t.Any],
+    encoding: str | None,
+    errors: str | None,
+    is_binary: t.Callable[[t.IO[t.Any], bool], bool],
+    find_binary: t.Callable[[t.IO[t.Any]], t.BinaryIO | None],
+    force_readable: bool = False,
+    force_writable: bool = False,
+) -> t.TextIO:
+    if is_binary(text_stream, False):
+        binary_reader = t.cast(t.BinaryIO, text_stream)
+    else:
+        text_stream = t.cast(t.TextIO, text_stream)
+        # If the stream looks compatible, and won't default to a
+        # misconfigured ascii encoding, return it as-is.
+        if _is_compatible_text_stream(text_stream, encoding, errors) and not (
+            encoding is None and _stream_is_misconfigured(text_stream)
+        ):
+            return text_stream
+
+        # Otherwise, get the underlying binary reader.
+        possible_binary_reader = find_binary(text_stream)
+
+        # If that's not possible, silently use the original reader
+        # and get mojibake instead of exceptions.
+        if possible_binary_reader is None:
+            return text_stream
+
+        binary_reader = possible_binary_reader
+
+    # Default errors to replace instead of strict in order to get
+    # something that works.
+    if errors is None:
+        errors = "replace"
+
+    # Wrap the binary stream in a text stream with the correct
+    # encoding parameters.
+    return _make_text_stream(
+        binary_reader,
+        encoding,
+        errors,
+        force_readable=force_readable,
+        force_writable=force_writable,
+    )
+
+
+def _force_correct_text_reader(
+    text_reader: t.IO[t.Any],
+    encoding: str | None,
+    errors: str | None,
+    force_readable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_reader,
+        encoding,
+        errors,
+        _is_binary_reader,
+        _find_binary_reader,
+        force_readable=force_readable,
+    )
+
+
+def _force_correct_text_writer(
+    text_writer: t.IO[t.Any],
+    encoding: str | None,
+    errors: str | None,
+    force_writable: bool = False,
+) -> t.TextIO:
+    return _force_correct_text_stream(
+        text_writer,
+        encoding,
+        errors,
+        _is_binary_writer,
+        _find_binary_writer,
+        force_writable=force_writable,
+    )
+
+
+def get_binary_stdin() -> t.BinaryIO:
+    reader = _find_binary_reader(sys.stdin)
+    if reader is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdin.")
+    return reader
+
+
+def get_binary_stdout() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stdout)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stdout.")
+    return writer
+
+
+def get_binary_stderr() -> t.BinaryIO:
+    writer = _find_binary_writer(sys.stderr)
+    if writer is None:
+        raise RuntimeError("Was not able to determine binary stream for sys.stderr.")
+    return writer
+
+
+def get_text_stdin(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdin, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_reader(sys.stdin, encoding, errors, force_readable=True)
+
+
+def get_text_stdout(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stdout, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stdout, encoding, errors, force_writable=True)
+
+
+def get_text_stderr(encoding: str | None = None, errors: str | None = None) -> t.TextIO:
+    rv = _get_windows_console_stream(sys.stderr, encoding, errors)
+    if rv is not None:
+        return rv
+    return _force_correct_text_writer(sys.stderr, encoding, errors, force_writable=True)
+
+
+def _wrap_io_open(
+    file: str | os.PathLike[str] | int,
+    mode: str,
+    encoding: str | None,
+    errors: str | None,
+) -> t.IO[t.Any]:
+    """Handles not passing ``encoding`` and ``errors`` in binary mode."""
+    if "b" in mode:
+        return open(file, mode)
+
+    return open(file, mode, encoding=encoding, errors=errors)
+
+
+def open_stream(
+    filename: str | os.PathLike[str],
+    mode: str = "r",
+    encoding: str | None = None,
+    errors: str | None = "strict",
+    atomic: bool = False,
+) -> tuple[t.IO[t.Any], bool]:
+    binary = "b" in mode
+    filename = os.fspath(filename)
+
+    # Standard streams first. These are simple because they ignore the
+    # atomic flag. Use fsdecode to handle Path("-").
+    if os.fsdecode(filename) == "-":
+        if any(m in mode for m in ["w", "a", "x"]):
+            if binary:
+                return get_binary_stdout(), False
+            return get_text_stdout(encoding=encoding, errors=errors), False
+        if binary:
+            return get_binary_stdin(), False
+        return get_text_stdin(encoding=encoding, errors=errors), False
+
+    # Non-atomic writes directly go out through the regular open functions.
+    if not atomic:
+        return _wrap_io_open(filename, mode, encoding, errors), True
+
+    # Some usability stuff for atomic writes
+    if "a" in mode:
+        raise ValueError(
+            "Appending to an existing file is not supported, because that"
+            " would involve an expensive `copy`-operation to a temporary"
+            " file. Open the file in normal `w`-mode and copy explicitly"
+            " if that's what you're after."
+        )
+    if "x" in mode:
+        raise ValueError("Use the `overwrite`-parameter instead.")
+    if "w" not in mode:
+        raise ValueError("Atomic writes only make sense with `w`-mode.")
+
+    # Atomic writes are more complicated.  They work by opening a file
+    # as a proxy in the same folder and then using the fdopen
+    # functionality to wrap it in a Python file.  Then we wrap it in an
+    # atomic file that moves the file over on close.
+    import errno
+    import random
+
+    try:
+        perm: int | None = os.stat(filename).st_mode
+    except OSError:
+        perm = None
+
+    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL
+
+    if binary:
+        flags |= getattr(os, "O_BINARY", 0)
+
+    while True:
+        tmp_filename = os.path.join(
+            os.path.dirname(filename),
+            f".__atomic-write{random.randrange(1 << 32):08x}",
+        )
+        try:
+            fd = os.open(tmp_filename, flags, 0o666 if perm is None else perm)
+            break
+        except OSError as e:
+            if e.errno == errno.EEXIST or (
+                os.name == "nt"
+                and e.errno == errno.EACCES
+                and os.path.isdir(e.filename)
+                and os.access(e.filename, os.W_OK)
+            ):
+                continue
+            raise
+
+    if perm is not None:
+        os.chmod(tmp_filename, perm)  # in case perm includes bits in umask
+
+    f = _wrap_io_open(fd, mode, encoding, errors)
+    af = _AtomicFile(f, tmp_filename, os.path.realpath(filename))
+    return t.cast(t.IO[t.Any], af), True
+
+
+class _AtomicFile:
+    def __init__(self, f: t.IO[t.Any], tmp_filename: str, real_filename: str) -> None:
+        self._f = f
+        self._tmp_filename = tmp_filename
+        self._real_filename = real_filename
+        self.closed = False
+
+    @property
+    def name(self) -> str:
+        return self._real_filename
+
+    def close(self, delete: bool = False) -> None:
+        if self.closed:
+            return
+        self._f.close()
+        os.replace(self._tmp_filename, self._real_filename)
+        self.closed = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._f, name)
+
+    def __enter__(self) -> _AtomicFile:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close(delete=exc_type is not None)
+
+    def __repr__(self) -> str:
+        return repr(self._f)
+
+
+def strip_ansi(value: str) -> str:
+    return _ansi_re.sub("", value)
+
+
+def _is_jupyter_kernel_output(stream: t.IO[t.Any]) -> bool:
+    while isinstance(stream, (_FixupStream, _NonClosingTextIOWrapper)):
+        stream = stream._stream
+
+    return stream.__class__.__module__.startswith("ipykernel.")
+
+
+def should_strip_ansi(
+    stream: t.IO[t.Any] | None = None, color: bool | None = None
+) -> bool:
+    if color is None:
+        if stream is None:
+            stream = sys.stdin
+        elif hasattr(stream, "color"):
+            # ._termui_impl._PagerWriter handles stripping ansi itself,
+            # so we don't need to strip it here
+            return False
+        return not isatty(stream) and not _is_jupyter_kernel_output(stream)
+    return not color
+
+
+# Double check is needed so mypy does not analyze this on Linux.
+if sys.platform.startswith("win") and WIN:
+    from ._winconsole import _get_windows_console_stream
+
+    def _get_argv_encoding() -> str:
+        import locale
+
+        return locale.getpreferredencoding()
+
+else:
+
+    def _get_argv_encoding() -> str:
+        return getattr(sys.stdin, "encoding", None) or sys.getfilesystemencoding()
+
+    def _get_windows_console_stream(
+        f: t.TextIO, encoding: str | None, errors: str | None
+    ) -> t.TextIO | None:
+        return None
+
+
+def term_len(x: str) -> int:
+    return len(strip_ansi(x))
+
+
+def isatty(stream: t.IO[t.Any]) -> bool:
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+def _make_cached_stream_func(
+    src_func: t.Callable[[], t.TextIO | None],
+    wrapper_func: t.Callable[[], t.TextIO],
+) -> t.Callable[[], t.TextIO | None]:
+    cache: cabc.MutableMapping[t.TextIO, t.TextIO] = WeakKeyDictionary()
+
+    def func() -> t.TextIO | None:
+        stream = src_func()
+
+        if stream is None:
+            return None
+
+        try:
+            rv = cache.get(stream)
+        except Exception:
+            rv = None
+        if rv is not None:
+            return rv
+        rv = wrapper_func()
+        try:
+            cache[stream] = rv
+        except Exception:
+            pass
+        return rv
+
+    return func
+
+
+_default_text_stdin = _make_cached_stream_func(lambda: sys.stdin, get_text_stdin)
+_default_text_stdout = _make_cached_stream_func(lambda: sys.stdout, get_text_stdout)
+_default_text_stderr = _make_cached_stream_func(lambda: sys.stderr, get_text_stderr)
+
+
+binary_streams: cabc.Mapping[str, t.Callable[[], t.BinaryIO]] = {
+    "stdin": get_binary_stdin,
+    "stdout": get_binary_stdout,
+    "stderr": get_binary_stderr,
+}
+
+text_streams: cabc.Mapping[str, t.Callable[[str | None, str | None], t.TextIO]] = {
+    "stdin": get_text_stdin,
+    "stdout": get_text_stdout,
+    "stderr": get_text_stderr,
+}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_termui_impl.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_termui_impl.py
new file mode 100644
index 0000000000000000000000000000000000000000..70aabf8f17c56ce5ed559ea88ce233a7944dbe3a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_termui_impl.py
@@ -0,0 +1,972 @@
+"""
+This module contains implementations for the termui module. To keep the
+import time of Click down, some infrequently used functionality is
+placed in this module and only imported as needed.
+"""
+
+from __future__ import annotations
+
+import collections.abc as cabc
+import contextlib
+import math
+import os
+import shlex
+import sys
+import time
+import typing as t
+from gettext import gettext as _
+from io import StringIO
+from pathlib import Path
+from types import TracebackType
+
+from ._compat import _default_text_stdout
+from ._compat import CYGWIN
+from ._compat import get_best_encoding
+from ._compat import isatty
+from ._compat import strip_ansi
+from ._compat import term_len
+from ._compat import WIN
+from .exceptions import ClickException
+from .utils import echo
+
+V = t.TypeVar("V")
+
+
+if os.name == "nt":
+    BEFORE_BAR = "\r"
+    AFTER_BAR = "\n"
+else:
+    BEFORE_BAR = "\r\033[?25l"
+    AFTER_BAR = "\033[?25h\n"
+
+
+class ProgressBar(t.Generic[V]):
+    def __init__(
+        self,
+        iterable: cabc.Iterable[V] | None,
+        length: int | None = None,
+        fill_char: str = "#",
+        empty_char: str = " ",
+        bar_template: str = "%(bar)s",
+        info_sep: str = "  ",
+        hidden: bool = False,
+        show_eta: bool = True,
+        show_percent: bool | None = None,
+        show_pos: bool = False,
+        item_show_func: t.Callable[[V | None], str | None] | None = None,
+        label: str | None = None,
+        file: t.TextIO | None = None,
+        color: bool | None = None,
+        update_min_steps: int = 1,
+        width: int = 30,
+    ) -> None:
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.bar_template = bar_template
+        self.info_sep = info_sep
+        self.hidden = hidden
+        self.show_eta = show_eta
+        self.show_percent = show_percent
+        self.show_pos = show_pos
+        self.item_show_func = item_show_func
+        self.label: str = label or ""
+
+        if file is None:
+            file = _default_text_stdout()
+
+            # There are no standard streams attached to write to. For example,
+            # pythonw on Windows.
+            if file is None:
+                file = StringIO()
+
+        self.file = file
+        self.color = color
+        self.update_min_steps = update_min_steps
+        self._completed_intervals = 0
+        self.width: int = width
+        self.autowidth: bool = width == 0
+
+        if length is None:
+            from operator import length_hint
+
+            length = length_hint(iterable, -1)
+
+            if length == -1:
+                length = None
+        if iterable is None:
+            if length is None:
+                raise TypeError("iterable or length is required")
+            iterable = t.cast("cabc.Iterable[V]", range(length))
+        self.iter: cabc.Iterable[V] = iter(iterable)
+        self.length = length
+        self.pos: int = 0
+        self.avg: list[float] = []
+        self.last_eta: float
+        self.start: float
+        self.start = self.last_eta = time.time()
+        self.eta_known: bool = False
+        self.finished: bool = False
+        self.max_width: int | None = None
+        self.entered: bool = False
+        self.current_item: V | None = None
+        self._is_atty = isatty(self.file)
+        self._last_line: str | None = None
+
+    def __enter__(self) -> ProgressBar[V]:
+        self.entered = True
+        self.render_progress()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.render_finish()
+
+    def __iter__(self) -> cabc.Iterator[V]:
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+        self.render_progress()
+        return self.generator()
+
+    def __next__(self) -> V:
+        # Iteration is defined in terms of a generator function,
+        # returned by iter(self); use that to define next(). This works
+        # because `self.iter` is an iterable consumed by that generator,
+        # so it is re-entry safe. Calling `next(self.generator())`
+        # twice works and does "what you want".
+        return next(iter(self))
+
+    def render_finish(self) -> None:
+        # Steps stay pending until they add up to update_min_steps, so a length
+        # that is not a multiple of it keeps a sub-threshold remainder that
+        # never reaches pos. Apply it so the bar settles on its true position.
+        if self._completed_intervals:
+            self.make_step(self._completed_intervals)
+            self._completed_intervals = 0
+            self.render_progress()
+
+        if self.hidden or not self._is_atty:
+            return
+        self.file.write(AFTER_BAR)
+        self.file.flush()
+
+    @property
+    def pct(self) -> float:
+        if self.finished:
+            return 1.0
+        return min(self.pos / (float(self.length or 1) or 1), 1.0)
+
+    @property
+    def time_per_iteration(self) -> float:
+        if not self.avg:
+            return 0.0
+        return sum(self.avg) / float(len(self.avg))
+
+    @property
+    def eta(self) -> float:
+        if self.length is not None and not self.finished:
+            return self.time_per_iteration * (self.length - self.pos)
+        return 0.0
+
+    def format_eta(self) -> str:
+        if self.eta_known:
+            t = int(self.eta)
+            seconds = t % 60
+            t //= 60
+            minutes = t % 60
+            t //= 60
+            hours = t % 24
+            t //= 24
+            if t > 0:
+                return "{d}{day_label} {h:02}:{m:02}:{s:02}".format(
+                    d=t,
+                    day_label=_("d"),
+                    h=hours,
+                    m=minutes,
+                    s=seconds,
+                )
+            else:
+                return f"{hours:02}:{minutes:02}:{seconds:02}"
+        return ""
+
+    def format_pos(self) -> str:
+        pos = str(self.pos)
+        if self.length is not None:
+            pos += f"/{self.length}"
+        return pos
+
+    def format_pct(self) -> str:
+        return f"{int(self.pct * 100): 4}%"[1:]
+
+    def format_bar(self) -> str:
+        if self.length is not None:
+            bar_length = int(self.pct * self.width)
+            bar = self.fill_char * bar_length
+            bar += self.empty_char * (self.width - bar_length)
+        elif self.finished:
+            bar = self.fill_char * self.width
+        else:
+            chars = list(self.empty_char * (self.width or 1))
+            if self.time_per_iteration != 0:
+                chars[
+                    int(
+                        (math.cos(self.pos * self.time_per_iteration) / 2.0 + 0.5)
+                        * self.width
+                    )
+                ] = self.fill_char
+            bar = "".join(chars)
+        return bar
+
+    def format_progress_line(self) -> str:
+        show_percent = self.show_percent
+
+        info_bits = []
+        if self.length is not None and show_percent is None:
+            show_percent = not self.show_pos
+
+        if self.show_pos:
+            info_bits.append(self.format_pos())
+        if show_percent:
+            info_bits.append(self.format_pct())
+        if self.show_eta and self.eta_known and not self.finished:
+            info_bits.append(self.format_eta())
+        if self.item_show_func is not None:
+            item_info = self.item_show_func(self.current_item)
+            if item_info is not None:
+                info_bits.append(item_info)
+
+        return (
+            self.bar_template
+            % {
+                "label": self.label,
+                "bar": self.format_bar(),
+                "info": self.info_sep.join(info_bits),
+            }
+        ).rstrip()
+
+    def render_progress(self) -> None:
+        if self.hidden:
+            return
+
+        if not self._is_atty:
+            # Only output the label once if the output is not a TTY.
+            if self._last_line != self.label:
+                self._last_line = self.label
+                echo(self.label, file=self.file, color=self.color)
+            return
+
+        buf = []
+        # Update width in case the terminal has been resized
+        if self.autowidth:
+            import shutil
+
+            old_width = self.width
+            self.width = 0
+            clutter_length = term_len(self.format_progress_line())
+            new_width = max(0, shutil.get_terminal_size().columns - clutter_length)
+            if new_width < old_width and self.max_width is not None:
+                buf.append(BEFORE_BAR)
+                buf.append(" " * self.max_width)
+                self.max_width = new_width
+            self.width = new_width
+
+        clear_width = self.width
+        if self.max_width is not None:
+            clear_width = self.max_width
+
+        buf.append(BEFORE_BAR)
+        line = self.format_progress_line()
+        line_len = term_len(line)
+        if self.max_width is None or self.max_width < line_len:
+            self.max_width = line_len
+
+        buf.append(line)
+        buf.append(" " * (clear_width - line_len))
+        line = "".join(buf)
+        # Render the line only if it changed.
+
+        if line != self._last_line:
+            self._last_line = line
+            echo(line, file=self.file, color=self.color, nl=False)
+            self.file.flush()
+
+    def make_step(self, n_steps: int) -> None:
+        self.pos += n_steps
+        if self.length is not None and self.pos >= self.length:
+            self.finished = True
+
+        if (time.time() - self.last_eta) < 1.0:
+            return
+
+        self.last_eta = time.time()
+
+        # self.avg is a rolling list of length <= 7 of steps where steps are
+        # defined as time elapsed divided by the total progress through
+        # self.length.
+        if self.pos:
+            step = (time.time() - self.start) / self.pos
+        else:
+            step = time.time() - self.start
+
+        self.avg = self.avg[-6:] + [step]
+
+        self.eta_known = self.length is not None
+
+    def update(self, n_steps: int, current_item: V | None = None) -> None:
+        """Update the progress bar by advancing a specified number of
+        steps, and optionally set the ``current_item`` for this new
+        position.
+
+        :param n_steps: Number of steps to advance.
+        :param current_item: Optional item to set as ``current_item``
+            for the updated position.
+
+        .. versionchanged:: 8.0
+            Added the ``current_item`` optional parameter.
+
+        .. versionchanged:: 8.0
+            Only render when the number of steps meets the
+            ``update_min_steps`` threshold.
+        """
+        if current_item is not None:
+            self.current_item = current_item
+
+        self._completed_intervals += n_steps
+
+        if self._completed_intervals >= self.update_min_steps:
+            self.make_step(self._completed_intervals)
+            self.render_progress()
+            self._completed_intervals = 0
+
+    def finish(self) -> None:
+        self.eta_known = False
+        self.current_item = None
+        self.finished = True
+
+    def generator(self) -> cabc.Iterator[V]:
+        """Return a generator which yields the items added to the bar
+        during construction, and updates the progress bar *after* the
+        yielded block returns.
+        """
+        # WARNING: the iterator interface for `ProgressBar` relies on
+        # this and only works because this is a simple generator which
+        # doesn't create or manage additional state. If this function
+        # changes, the impact should be evaluated both against
+        # `iter(bar)` and `next(bar)`. `next()` in particular may call
+        # `self.generator()` repeatedly, and this must remain safe in
+        # order for that interface to work.
+        if not self.entered:
+            raise RuntimeError("You need to use progress bars in a with block.")
+
+        if not self._is_atty:
+            yield from self.iter
+        else:
+            for rv in self.iter:
+                self.current_item = rv
+
+                # This allows show_item_func to be updated before the
+                # item is processed. Only trigger at the beginning of
+                # the update interval.
+                if self._completed_intervals == 0:
+                    self.render_progress()
+
+                yield rv
+                self.update(1)
+
+            self.finish()
+            self.render_progress()
+
+
+class _PagerWriter:
+    """Wrap a pager's output stream to strip ANSI styling when colors are
+    disabled.
+
+    The wrapped stream is owned by the pager strategy that produced it, so this
+    wrapper never closes it: ``_pipepager`` closes its pipe to signal EOF to the
+    pager process, ``_tempfilepager`` closes and removes its temporary file, and
+    ``_nullpager`` leaves an external stream such as ``sys.stdout`` untouched.
+
+    The ``color`` attribute lets :func:`click.echo` detect that ANSI stripping
+    is handled here, so it doesn't strip a second time (see
+    :func:`._compat.should_strip_ansi`).
+    """
+
+    def __init__(self, stream: t.TextIO, color: bool) -> None:
+        self._stream = stream
+        self.color = color
+
+    def write(self, text: str) -> int:
+        if not self.color:
+            text = strip_ansi(text)
+
+        return self._stream.write(text)
+
+    def writelines(self, lines: cabc.Iterable[str]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def flush(self) -> None:
+        self._stream.flush()
+
+    def close(self) -> None:
+        # The pager strategy owns the stream's lifecycle. Flush pending output,
+        # but never close the underlying stream from here.
+        self._stream.flush()
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._stream, name)
+
+
+def _resolve_pager_command(cmd_parts: list[str]) -> tuple[Path, list[str]] | None:
+    """Resolve a pager ``argv`` to an absolute command path and its parameters.
+
+    The command is looked up with :func:`shutil.which`, which the
+    :mod:`subprocess` docs recommend on every platform for an unqualified name:
+    https://docs.python.org/3/library/subprocess.html#popen-constructor
+
+    Returns ``None`` when there is no command to run or it is not on the path,
+    leaving the caller to pick a fallback.
+    """
+    if not cmd_parts:
+        return None
+
+    import shutil
+
+    cmd_filepath = shutil.which(cmd_parts[0])
+
+    if not cmd_filepath:
+        return None
+
+    # Normalize to an absolute path without resolving symlinks: multi-call
+    # binaries such as busybox derive their identity from the link they are
+    # invoked through, so resolving less -> busybox makes them misbehave.
+    # See https://github.com/pallets/click/issues/2943 and
+    # https://github.com/pallets/click/pull/2944
+    return Path(cmd_filepath).absolute(), cmd_parts[1:]
+
+
+def _pager_contextmanager(
+    color: bool | None = None,
+) -> t.ContextManager[tuple[t.TextIO, bool | None]]:
+    """Decide what method to use for paging through text."""
+    stdout = _default_text_stdout()
+
+    # There are no standard streams attached to write to. For example,
+    # pythonw on Windows.
+    if stdout is None:
+        stdout = StringIO()
+
+    if not isatty(sys.stdin) or not isatty(stdout):
+        return _nullpager(stdout, color)
+
+    # Split using POSIX mode (the default) so that quote characters are
+    # stripped from tokens and quoted Windows paths are preserved.
+    # Non-POSIX mode retains quotes in tokens, and wrapping tokens
+    # with shlex.quote re-introduces quoting issues on Windows.
+    pager_cmd_parts = shlex.split(os.environ.get("PAGER", ""))
+
+    if pager_cmd_parts:
+        # Piping to `more` on Windows adds spurious \r\n, so it gets the temp
+        # file strategy whatever the user asked for.
+        use_tempfile = WIN
+    else:
+        if os.environ.get("TERM") in ("dumb", "emacs"):
+            return _nullpager(stdout, color)
+
+        use_tempfile = WIN or sys.platform.startswith("os2")
+        pager_cmd_parts = ["more"] if use_tempfile else ["less"]
+
+    resolved = _resolve_pager_command(pager_cmd_parts)
+
+    if resolved is None:
+        # Page through stdout, which _nullpager leaves open for its owner.
+        return _nullpager(stdout, color)
+
+    cmd_path, cmd_params = resolved
+
+    if use_tempfile:
+        return _tempfilepager(cmd_path, cmd_params, color)
+
+    return _pipepager(cmd_path, cmd_params, color)
+
+
+@contextlib.contextmanager
+def get_pager_file(color: bool | None = None) -> t.Generator[t.TextIO, None, None]:
+    """Context manager.
+
+    Yields a writable file-like object which can be used as an output pager.
+
+    .. versionadded:: 8.4.0
+
+    :param color: controls if the pager supports ANSI colors or not.  The
+                  default is autodetection.
+    """
+    with _pager_contextmanager(color=color) as (stream, color):
+        # Every pager strategy yields a text stream, so the only thing left to
+        # do is strip ANSI styling when colors are disabled. A strategy yields
+        # None when it has no opinion on colors, which settles as off here. The
+        # wrapper does not close the stream: each strategy owns its stream's
+        # lifecycle.
+        writer = _PagerWriter(stream, color=bool(color))
+        try:
+            yield t.cast(t.TextIO, writer)
+        finally:
+            writer.flush()
+
+
+def _less_uses_raw_mode(less_env: str, cmd_params: list[str]) -> bool:
+    """Detect a raw-control-characters request in a ``less`` invocation.
+
+    Parses the tokens of the ``LESS`` environment variable and the command
+    line: only short-option clusters (``-R``, ``-rX``, ``-XrY``) and the
+    ``--raw-control-chars`` long option request raw mode. Filenames and
+    long-option values may carry the letter ``r`` without being such a
+    request.
+    """
+    try:
+        env_tokens = shlex.split(less_env)
+    except ValueError:
+        # Unbalanced quotes make ``LESS`` unparsable: fall back to whitespace
+        # splitting rather than failing the pager over it.
+        env_tokens = less_env.split()
+    tokens = env_tokens + cmd_params
+
+    for token in tokens:
+        if token.startswith("--"):
+            if token.casefold() == "--raw-control-chars":
+                return True
+        elif token.startswith("-") and len(token) > 1:
+            if "r" in token[1:].casefold():
+                return True
+
+    return False
+
+
+@contextlib.contextmanager
+def _pipepager(
+    cmd_path: Path, cmd_params: list[str], color: bool | None = None
+) -> t.Iterator[tuple[t.TextIO, bool | None]]:
+    """Page through text by feeding it to another program.
+
+    Invokes the pager via :class:`subprocess.Popen` with an ``argv`` list.
+
+    Invoking a pager through this might support colors: if piping to
+    ``less`` and the user hasn't decided on colors, ``LESS=-R`` is set
+    automatically.
+    """
+    import subprocess
+
+    # Make a local copy of the environment to not affect the global one.
+    env = dict(os.environ)
+
+    # If we're piping to less and the user hasn't decided on colors, we enable
+    # them: either the invocation already requests raw control characters, or
+    # ``LESS=-R`` is injected. Match on the stem so a resolved ``less.exe`` is
+    # recognized like bare ``less``, case-insensitively on Windows since its
+    # filesystems are. POSIX keeps an exact match.
+    cmd_name = cmd_path.stem
+    if WIN:
+        # ``_pager_contextmanager`` currently routes every Windows invocation
+        # to ``_tempfilepager``, so this branch is not reachable on Windows
+        # today: it keeps the detection correct should that routing ever
+        # change.
+        cmd_name = cmd_name.casefold()
+
+    if color is None and cmd_name == "less":
+        less_env = os.environ.get("LESS", "")
+        if _less_uses_raw_mode(less_env, cmd_params):
+            color = True
+        elif not less_env and not cmd_params:
+            env["LESS"] = "-R"
+            color = True
+
+    c = subprocess.Popen(
+        [str(cmd_path)] + cmd_params,
+        shell=False,
+        stdin=subprocess.PIPE,
+        env=env,
+        errors="replace",
+        text=True,
+    )
+    # With ``text=True``, ``c.stdin`` is already a text stream that encodes
+    # writes for the pager process (honoring ``errors="replace"``).
+    stdin = t.cast(t.TextIO, c.stdin)
+    try:
+        yield stdin, color
+    except BrokenPipeError:
+        # In case the pager exited unexpectedly, ignore the broken pipe error.
+        pass
+    except Exception as e:
+        # In case there is an exception we want to close the pager immediately
+        # and let the caller handle it.
+        # Otherwise the pager will keep running, and the user may not notice
+        # the error message, or worse yet it may leave the terminal in a broken state.
+        c.terminate()
+        raise e
+    finally:
+        # We must close stdin and wait for the pager to exit before we continue
+        try:
+            stdin.close()
+        # Close implies flush, so it might throw a BrokenPipeError if the pager
+        # process exited already.
+        except BrokenPipeError:
+            pass
+
+        # Less doesn't respect ^C, but catches it for its own UI purposes (aborting
+        # search or other commands inside less).
+        #
+        # That means when the user hits ^C, the parent process (click) terminates,
+        # but less is still alive, paging the output and messing up the terminal.
+        #
+        # If the user wants to make the pager exit on ^C, they should set
+        # `LESS='-K'`. It's not our decision to make.
+        while True:
+            try:
+                c.wait()
+            except KeyboardInterrupt:
+                pass
+            else:
+                break
+
+
+@contextlib.contextmanager
+def _tempfilepager(
+    cmd_path: Path, cmd_params: list[str], color: bool | None = None
+) -> t.Iterator[tuple[t.TextIO, bool | None]]:
+    """Page through text by invoking a program on a temporary file.
+
+    Used as the primary pager strategy on Windows (where piping to
+    ``more`` adds spurious ``\\r\\n``), and as a fallback on other
+    platforms. The command is invoked with any parameters from ``PAGER``
+    followed by the temporary file name.
+    """
+    import subprocess
+    import tempfile
+
+    encoding = get_best_encoding(sys.stdout)
+    # On Windows, NamedTemporaryFile cannot be opened by another process
+    # while Python still has it open, so we use delete=False and clean up manually
+    # rather than using a contextmanager here.
+    f = tempfile.NamedTemporaryFile(
+        mode="w", encoding=encoding, errors="replace", delete=False
+    )
+    try:
+        yield t.cast(t.TextIO, f), color
+        f.flush()
+        f.close()
+        subprocess.call([str(cmd_path), *cmd_params, f.name])
+    finally:
+        # An error raised while paging skips the close() above, and Windows
+        # refuses to unlink a file the process still holds open. Closing here
+        # keeps that PermissionError from replacing the original exception.
+        # close() is idempotent, so this is a no-op on the success path.
+        f.close()
+        os.unlink(f.name)
+
+
+@contextlib.contextmanager
+def _nullpager(
+    stream: t.TextIO, color: bool | None = None
+) -> t.Iterator[tuple[t.TextIO, bool | None]]:
+    """Simply print unformatted text. This is the ultimate fallback.
+
+    The stream comes from elsewhere (typically ``sys.stdout``), so its lifecycle
+    is left untouched: :class:`_PagerWriter` never closes what it wraps, and it
+    is the only thing :func:`get_pager_file` hands to the caller.
+    """
+    yield stream, color
+
+
+class Editor:
+    def __init__(
+        self,
+        editor: str | None = None,
+        env: cabc.Mapping[str, str] | None = None,
+        require_save: bool = True,
+        extension: str = ".txt",
+    ) -> None:
+        self.editor = editor
+        self.env = env
+        self.require_save = require_save
+        self.extension = extension
+
+    def get_editor(self) -> str:
+        if self.editor is not None:
+            return self.editor
+        for key in "VISUAL", "EDITOR":
+            rv = os.environ.get(key)
+            if rv:
+                return rv
+        if WIN:
+            return "notepad"
+
+        from shutil import which
+
+        for editor in "sensible-editor", "vim", "nano":
+            if which(editor) is not None:
+                return editor
+        return "vi"
+
+    def edit_files(self, filenames: cabc.Iterable[str | os.PathLike[str]]) -> None:
+        """Open files in the user's editor."""
+        import shlex
+        import subprocess
+
+        editor = self.get_editor()
+        environ: dict[str, str] | None = None
+
+        if self.env:
+            environ = os.environ.copy()
+            environ.update(self.env)
+
+        try:
+            # Split in POSIX mode (the default) for the same reasons as
+            # in pager(): strips quotes from tokens and preserves quoted
+            # Windows paths.
+            c = subprocess.Popen(
+                args=shlex.split(editor) + list(filenames),
+                env=environ,
+            )
+            exit_code = c.wait()
+            if exit_code != 0:
+                raise ClickException(
+                    _("{editor}: Editing failed").format(editor=editor)
+                )
+        except OSError as e:
+            raise ClickException(
+                _("{editor}: Editing failed: {e}").format(editor=editor, e=e)
+            ) from e
+
+    @t.overload
+    def edit(self, text: bytes | bytearray) -> bytes | None: ...
+
+    # We cannot know whether or not the type expected is str or bytes when None
+    # is passed, so str is returned as that was what was done before.
+    @t.overload
+    def edit(self, text: str | None) -> str | None: ...
+
+    def edit(self, text: str | bytes | bytearray | None) -> str | bytes | None:
+        import tempfile
+
+        if text is None:
+            data: bytes | bytearray = b""
+        elif isinstance(text, (bytes, bytearray)):
+            data = text
+        else:
+            if text and not text.endswith("\n"):
+                text += "\n"
+
+            if WIN:
+                data = text.replace("\n", "\r\n").encode("utf-8-sig")
+            else:
+                data = text.encode("utf-8")
+
+        fd, name = tempfile.mkstemp(prefix="editor-", suffix=self.extension)
+        f: t.BinaryIO
+
+        try:
+            with os.fdopen(fd, "wb") as f:
+                f.write(data)
+
+            # If the filesystem resolution is 1 second, like Mac OS
+            # 10.12 Extended, or 2 seconds, like FAT32, and the editor
+            # closes very fast, require_save can fail. Set the modified
+            # time to be 2 seconds in the past to work around this.
+            os.utime(name, (os.path.getatime(name), os.path.getmtime(name) - 2))
+            # Depending on the resolution, the exact value might not be
+            # recorded, so get the new recorded value.
+            timestamp = os.path.getmtime(name)
+
+            self.edit_files((name,))
+
+            if self.require_save and os.path.getmtime(name) == timestamp:
+                return None
+
+            with open(name, "rb") as f:
+                rv = f.read()
+
+            if isinstance(text, (bytes, bytearray)):
+                return rv
+
+            return rv.decode("utf-8-sig").replace("\r\n", "\n")
+        finally:
+            os.unlink(name)
+
+
+def open_url(url: str, wait: bool = False, locate: bool = False) -> int:
+    import subprocess
+
+    def _unquote_file(url: str) -> str:
+        from urllib.parse import unquote
+
+        if url.startswith("file://"):
+            url = unquote(url[7:])
+
+        return url
+
+    if sys.platform == "darwin":
+        args = ["open"]
+        if wait:
+            args.append("-W")
+        if locate:
+            args.append("-R")
+        args.append(_unquote_file(url))
+        null = open("/dev/null", "w")
+        try:
+            return subprocess.Popen(args, stderr=null).wait()
+        finally:
+            null.close()
+    elif WIN:
+        if locate:
+            url = _unquote_file(url)
+            args = ["explorer", "/select,", url]
+            try:
+                return subprocess.call(args)
+            except OSError:
+                return 127
+        else:
+            try:
+                os.startfile(url)  # type: ignore[attr-defined]
+            except OSError:
+                return 127
+            return 0
+    elif CYGWIN:
+        if locate:
+            url = _unquote_file(url)
+            args = ["cygstart", os.path.dirname(url)]
+        else:
+            args = ["cygstart"]
+            if wait:
+                args.append("-w")
+            args.append(url)
+        try:
+            return subprocess.call(args)
+        except OSError:
+            # Command not found
+            return 127
+
+    try:
+        if locate:
+            url = os.path.dirname(_unquote_file(url)) or "."
+        else:
+            url = _unquote_file(url)
+        c = subprocess.Popen(["xdg-open", url])
+        if wait:
+            return c.wait()
+        return 0
+    except OSError:
+        if url.startswith(("http://", "https://")) and not locate and not wait:
+            import webbrowser
+
+            webbrowser.open(url)
+            return 0
+        return 1
+
+
+def _translate_ch_to_exc(ch: str) -> None:
+    if ch == "\x03":
+        raise KeyboardInterrupt()
+
+    if ch == "\x04" and not WIN:  # Unix-like, Ctrl+D
+        raise EOFError()
+
+    if ch == "\x1a" and WIN:  # Windows, Ctrl+Z
+        raise EOFError()
+
+
+if sys.platform == "win32":
+    import msvcrt
+
+    @contextlib.contextmanager
+    def raw_terminal() -> cabc.Iterator[int]:
+        yield -1
+
+    def getchar(echo: bool) -> str:
+        # The function `getch` will return a bytes object corresponding to
+        # the pressed character. Since Windows 10 build 1803, it will also
+        # return \x00 when called a second time after pressing a regular key.
+        #
+        # `getwch` does not share this probably-bugged behavior. Moreover, it
+        # returns a Unicode object by default, which is what we want.
+        #
+        # Either of these functions will return \x00 or \xe0 to indicate
+        # a special key, and you need to call the same function again to get
+        # the "rest" of the code. The fun part is that \u00e0 is
+        # "latin small letter a with grave", so if you type that on a French
+        # keyboard, you _also_ get a \xe0.
+        # E.g., consider the Up arrow. This returns \xe0 and then \x48. The
+        # resulting Unicode string reads as "a with grave" + "capital H".
+        # This is indistinguishable from when the user actually types
+        # "a with grave" and then "capital H".
+        #
+        # When \xe0 is returned, we assume it's part of a special-key sequence
+        # and call `getwch` again, but that means that when the user types
+        # the \u00e0 character, `getchar` doesn't return until a second
+        # character is typed.
+        # The alternative is returning immediately, but that would mess up
+        # cross-platform handling of arrow keys and others that start with
+        # \xe0. Another option is using `getch`, but then we can't reliably
+        # read non-ASCII characters, because return values of `getch` are
+        # limited to the current 8-bit codepage.
+        #
+        # Anyway, Click doesn't claim to do this Right(tm), and using `getwch`
+        # is doing the right thing in more situations than with `getch`.
+
+        if echo:
+            func = t.cast(t.Callable[[], str], msvcrt.getwche)
+        else:
+            func = t.cast(t.Callable[[], str], msvcrt.getwch)
+
+        rv = func()
+
+        if rv in ("\x00", "\xe0"):
+            # \x00 and \xe0 are control characters that indicate special key,
+            # see above.
+            rv += func()
+
+        _translate_ch_to_exc(rv)
+        return rv
+
+else:
+    import termios
+    import tty
+
+    @contextlib.contextmanager
+    def raw_terminal() -> cabc.Iterator[int]:
+        f: t.TextIO | None
+        fd: int
+
+        if not isatty(sys.stdin):
+            f = open("/dev/tty")
+            fd = f.fileno()
+        else:
+            fd = sys.stdin.fileno()
+            f = None
+
+        try:
+            old_settings = termios.tcgetattr(fd)
+
+            try:
+                tty.setraw(fd)
+                yield fd
+            finally:
+                termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+                sys.stdout.flush()
+
+                if f is not None:
+                    f.close()
+        except termios.error:
+            pass
+
+    def getchar(echo: bool) -> str:
+        with raw_terminal() as fd:
+            ch = os.read(fd, 32).decode(get_best_encoding(sys.stdin), "replace")
+
+            if echo and isatty(sys.stdout):
+                sys.stdout.write(ch)
+
+            _translate_ch_to_exc(ch)
+            return ch
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_textwrap.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_textwrap.py
new file mode 100644
index 0000000000000000000000000000000000000000..82840f2dff3ce627712c0ece2752382a0f7dab8b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_textwrap.py
@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import textwrap
+from contextlib import contextmanager
+
+from ._compat import _ansi_re
+from ._compat import term_len
+
+
+def _truncate_visible(text: str, n: int) -> str:
+    """Return the longest prefix of ``text`` containing at most ``n`` visible
+    characters.
+
+    ANSI escape sequences inside the prefix are kept intact and do not count
+    toward the visible width. A cut is never placed inside an escape sequence.
+    """
+    if n <= 0:
+        return ""
+
+    visible = 0
+    i = 0
+    cut = 0
+    end = len(text)
+    while i < end:
+        m = _ansi_re.match(text, i)
+        if m is not None:
+            i = m.end()
+            continue
+        visible += 1
+        i += 1
+        cut = i
+        if visible >= n:
+            break
+    return text[:cut]
+
+
+class TextWrapper(textwrap.TextWrapper):
+    """``textwrap.TextWrapper`` variant that measures widths by visible
+    character count.
+
+    ANSI escape sequences embedded in chunks, indents, or the placeholder are
+    excluded from the width budget. Without this, styled help text (a styled
+    ``Usage:`` prefix, a colorized option name, ...) would be wrapped earlier
+    than its visible length warrants and tokens would split mid-word.
+    """
+
+    def _handle_long_word(
+        self,
+        reversed_chunks: list[str],
+        cur_line: list[str],
+        cur_len: int,
+        width: int,
+    ) -> None:
+        space_left = max(width - cur_len, 1)
+
+        if self.break_long_words:
+            last = reversed_chunks[-1]
+            cut = _truncate_visible(last, space_left)
+            res = last[len(cut) :]
+            cur_line.append(cut)
+            reversed_chunks[-1] = res
+        elif not cur_line:
+            cur_line.append(reversed_chunks.pop())
+
+    def _wrap_chunks(self, chunks: list[str]) -> list[str]:
+        """Wrap chunks counting widths in visible characters.
+
+        Mirrors the algorithm of :meth:`textwrap.TextWrapper._wrap_chunks`
+        with every width measurement routed through
+        :func:`click._compat.term_len` instead of :func:`len`, so ANSI escape
+        bytes in chunks, indents, or the placeholder do not inflate the count.
+
+        .. seealso::
+            :class:`textwrap.TextWrapper` in the Python standard library documentation:
+            https://docs.python.org/3/library/textwrap.html#textwrap.TextWrapper
+
+            Reference implementation in CPython:
+            https://github.com/python/cpython/blob/main/Lib/textwrap.py
+        """
+        lines: list[str] = []
+        if self.width <= 0:
+            raise ValueError(f"invalid width {self.width!r} (must be > 0)")
+        if self.max_lines is not None:
+            if self.max_lines > 1:
+                indent = self.subsequent_indent
+            else:
+                indent = self.initial_indent
+            if term_len(indent) + term_len(self.placeholder.lstrip()) > self.width:
+                raise ValueError("placeholder too large for max width")
+
+        chunks.reverse()
+
+        while chunks:
+            cur_line: list[str] = []
+            cur_len = 0
+
+            if lines:
+                indent = self.subsequent_indent
+            else:
+                indent = self.initial_indent
+
+            width = self.width - term_len(indent)
+
+            if self.drop_whitespace and chunks[-1].strip() == "" and lines:
+                del chunks[-1]
+
+            while chunks:
+                n = term_len(chunks[-1])
+
+                if cur_len + n <= width:
+                    cur_line.append(chunks.pop())
+                    cur_len += n
+
+                else:
+                    break
+
+            if chunks and term_len(chunks[-1]) > width:
+                self._handle_long_word(chunks, cur_line, cur_len, width)
+                cur_len = sum(map(term_len, cur_line))
+
+            if self.drop_whitespace and cur_line and cur_line[-1].strip() == "":
+                cur_len -= term_len(cur_line[-1])
+                del cur_line[-1]
+
+            if cur_line:
+                if (
+                    self.max_lines is None
+                    or len(lines) + 1 < self.max_lines
+                    or (
+                        not chunks
+                        or self.drop_whitespace
+                        and len(chunks) == 1
+                        and not chunks[0].strip()
+                    )
+                    and cur_len <= width
+                ):
+                    lines.append(indent + "".join(cur_line))
+                else:
+                    while cur_line:
+                        if (
+                            cur_line[-1].strip()
+                            and cur_len + term_len(self.placeholder) <= width
+                        ):
+                            cur_line.append(self.placeholder)
+                            lines.append(indent + "".join(cur_line))
+                            break
+                        cur_len -= term_len(cur_line[-1])
+                        del cur_line[-1]
+                    else:
+                        if lines:
+                            prev_line = lines[-1].rstrip()
+                            if (
+                                term_len(prev_line) + term_len(self.placeholder)
+                                <= self.width
+                            ):
+                                lines[-1] = prev_line + self.placeholder
+                                break
+                        lines.append(indent + self.placeholder.lstrip())
+                    break
+
+        return lines
+
+    @contextmanager
+    def extra_indent(self, indent: str) -> cabc.Iterator[None]:
+        old_initial_indent = self.initial_indent
+        old_subsequent_indent = self.subsequent_indent
+        self.initial_indent += indent
+        self.subsequent_indent += indent
+
+        try:
+            yield
+        finally:
+            self.initial_indent = old_initial_indent
+            self.subsequent_indent = old_subsequent_indent
+
+    def indent_only(self, text: str) -> str:
+        rv = []
+
+        for idx, line in enumerate(text.splitlines()):
+            indent = self.initial_indent
+
+            if idx > 0:
+                indent = self.subsequent_indent
+
+            rv.append(f"{indent}{line}")
+
+        return "\n".join(rv)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..05ee2e99757adb19882664e1fc0377ac29c92f80
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_utils.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+import enum
+import typing as t
+
+
+class Sentinel(enum.Enum):
+    """Enum used to define sentinel values.
+
+    .. seealso::
+
+        `PEP 661 - Sentinel Values <https://peps.python.org/pep-0661/>`_.
+    """
+
+    UNSET = object()
+    FLAG_NEEDS_VALUE = object()
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}.{self.name}"
+
+
+UNSET: t.Literal[Sentinel.UNSET] = Sentinel.UNSET
+"""Sentinel used to indicate that a value is not set."""
+
+FLAG_NEEDS_VALUE: t.Literal[Sentinel.FLAG_NEEDS_VALUE] = Sentinel.FLAG_NEEDS_VALUE
+"""Sentinel used to indicate an option was passed as a flag without a
+value but is not a flag option.
+
+``Option.consume_value`` uses this to prompt or use the ``flag_value``.
+"""
+
+T_UNSET: t.TypeAlias = t.Literal[Sentinel.UNSET]
+"""Type hint for the :data:`UNSET` sentinel value."""
+
+T_FLAG_NEEDS_VALUE: t.TypeAlias = t.Literal[Sentinel.FLAG_NEEDS_VALUE]
+"""Type hint for the :data:`FLAG_NEEDS_VALUE` sentinel value."""
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_winconsole.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_winconsole.py
new file mode 100644
index 0000000000000000000000000000000000000000..d25178d66ff7a9c8a1da52e61379da240be625b6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/_winconsole.py
@@ -0,0 +1,297 @@
+# This module is based on the excellent work by Adam Bartoš who
+# provided a lot of what went into the implementation here in
+# the discussion to issue1602 in the Python bug tracker.
+#
+# There are some general differences in regards to how this works
+# compared to the original patches as we do not need to patch
+# the entire interpreter but just work in our little world of
+# echo and prompt.
+from __future__ import annotations
+
+import collections.abc as cabc
+import io
+import sys
+import time
+import typing as t
+from ctypes import Array
+from ctypes import byref
+from ctypes import c_char
+from ctypes import c_char_p
+from ctypes import c_int
+from ctypes import c_ssize_t
+from ctypes import c_ulong
+from ctypes import c_void_p
+from ctypes import POINTER
+from ctypes import py_object
+from ctypes import Structure
+from ctypes.wintypes import DWORD
+from ctypes.wintypes import HANDLE
+from ctypes.wintypes import LPCWSTR
+from ctypes.wintypes import LPWSTR
+from gettext import gettext as _
+
+from ._compat import _NonClosingTextIOWrapper
+
+assert sys.platform == "win32"
+import msvcrt  # noqa: E402
+from ctypes import windll  # noqa: E402
+from ctypes import WINFUNCTYPE  # noqa: E402
+
+c_ssize_p = POINTER(c_ssize_t)
+
+kernel32 = windll.kernel32
+GetStdHandle = kernel32.GetStdHandle
+ReadConsoleW = kernel32.ReadConsoleW
+WriteConsoleW = kernel32.WriteConsoleW
+GetConsoleMode = kernel32.GetConsoleMode
+GetLastError = kernel32.GetLastError
+GetCommandLineW = WINFUNCTYPE(LPWSTR)(("GetCommandLineW", windll.kernel32))
+CommandLineToArgvW = WINFUNCTYPE(POINTER(LPWSTR), LPCWSTR, POINTER(c_int))(
+    ("CommandLineToArgvW", windll.shell32)
+)
+LocalFree = WINFUNCTYPE(c_void_p, c_void_p)(("LocalFree", windll.kernel32))
+
+STDIN_HANDLE = GetStdHandle(-10)
+STDOUT_HANDLE = GetStdHandle(-11)
+STDERR_HANDLE = GetStdHandle(-12)
+
+PyBUF_SIMPLE = 0
+PyBUF_WRITABLE = 1
+
+ERROR_SUCCESS = 0
+ERROR_NOT_ENOUGH_MEMORY = 8
+ERROR_OPERATION_ABORTED = 995
+
+STDIN_FILENO = 0
+STDOUT_FILENO = 1
+STDERR_FILENO = 2
+
+EOF = b"\x1a"
+MAX_BYTES_WRITTEN = 32767
+
+if t.TYPE_CHECKING:
+    try:
+        # Using `typing_extensions.Buffer` instead of `collections.abc`
+        # on Windows for some reason does not have `Sized` implemented.
+        from collections.abc import Buffer  # type: ignore
+    except ImportError:
+        from typing_extensions import Buffer
+
+try:
+    from ctypes import pythonapi
+except ImportError:
+    # On PyPy we cannot get buffers so our ability to operate here is
+    # severely limited.
+    get_buffer = None
+else:
+
+    class Py_buffer(Structure):
+        _fields_ = [  # noqa: RUF012
+            ("buf", c_void_p),
+            ("obj", py_object),
+            ("len", c_ssize_t),
+            ("itemsize", c_ssize_t),
+            ("readonly", c_int),
+            ("ndim", c_int),
+            ("format", c_char_p),
+            ("shape", c_ssize_p),
+            ("strides", c_ssize_p),
+            ("suboffsets", c_ssize_p),
+            ("internal", c_void_p),
+        ]
+
+    PyObject_GetBuffer = pythonapi.PyObject_GetBuffer
+    PyBuffer_Release = pythonapi.PyBuffer_Release
+
+    def get_buffer(obj: Buffer, writable: bool = False) -> Array[c_char]:
+        buf = Py_buffer()
+        flags: int = PyBUF_WRITABLE if writable else PyBUF_SIMPLE
+        PyObject_GetBuffer(py_object(obj), byref(buf), flags)
+
+        try:
+            buffer_type = c_char * buf.len
+            out: Array[c_char] = buffer_type.from_address(buf.buf)
+            return out
+        finally:
+            PyBuffer_Release(byref(buf))
+
+
+class _WindowsConsoleRawIOBase(io.RawIOBase):
+    def __init__(self, handle: int | None) -> None:
+        self.handle = handle
+
+    def isatty(self) -> t.Literal[True]:
+        super().isatty()
+        return True
+
+
+class _WindowsConsoleReader(_WindowsConsoleRawIOBase):
+    def readable(self) -> t.Literal[True]:
+        return True
+
+    def readinto(self, b: Buffer) -> int:
+        bytes_to_be_read = len(b)
+        if not bytes_to_be_read:
+            return 0
+        elif bytes_to_be_read % 2:
+            raise ValueError(
+                "cannot read odd number of bytes from UTF-16-LE encoded console"
+            )
+
+        buffer = get_buffer(b, writable=True)
+        code_units_to_be_read = bytes_to_be_read // 2
+        code_units_read = c_ulong()
+
+        rv = ReadConsoleW(
+            HANDLE(self.handle),
+            buffer,
+            code_units_to_be_read,
+            byref(code_units_read),
+            None,
+        )
+        if GetLastError() == ERROR_OPERATION_ABORTED:
+            # wait for KeyboardInterrupt
+            time.sleep(0.1)
+        if not rv:
+            raise OSError(_("Windows error: {error}").format(error=GetLastError()))
+
+        if buffer[0] == EOF:
+            return 0
+        return 2 * code_units_read.value
+
+
+class _WindowsConsoleWriter(_WindowsConsoleRawIOBase):
+    def writable(self) -> t.Literal[True]:
+        return True
+
+    @staticmethod
+    def _get_error_message(errno: int) -> str:
+        if errno == ERROR_SUCCESS:
+            return "ERROR_SUCCESS"
+        elif errno == ERROR_NOT_ENOUGH_MEMORY:
+            return "ERROR_NOT_ENOUGH_MEMORY"
+        return _("Windows error: {error}").format(error=errno)
+
+    def write(self, b: Buffer) -> int:
+        bytes_to_be_written = len(b)
+        buf = get_buffer(b)
+        code_units_to_be_written = min(bytes_to_be_written, MAX_BYTES_WRITTEN) // 2
+        code_units_written = c_ulong()
+
+        WriteConsoleW(
+            HANDLE(self.handle),
+            buf,
+            code_units_to_be_written,
+            byref(code_units_written),
+            None,
+        )
+        bytes_written = 2 * code_units_written.value
+
+        if bytes_written == 0 and bytes_to_be_written > 0:
+            raise OSError(self._get_error_message(GetLastError()))
+        return bytes_written
+
+
+class ConsoleStream:
+    def __init__(self, text_stream: t.TextIO, byte_stream: t.BinaryIO) -> None:
+        self._text_stream = text_stream
+        self.buffer = byte_stream
+
+    @property
+    def name(self) -> str:
+        return self.buffer.name
+
+    def write(self, x: t.AnyStr) -> int:
+        if isinstance(x, str):
+            return self._text_stream.write(x)
+        try:
+            self.flush()
+        except Exception:
+            pass
+        return self.buffer.write(x)
+
+    def writelines(self, lines: cabc.Iterable[t.AnyStr]) -> None:
+        for line in lines:
+            self.write(line)
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._text_stream, name)
+
+    def isatty(self) -> bool:
+        return self.buffer.isatty()
+
+    def __repr__(self) -> str:
+        return f"<ConsoleStream name={self.name!r} encoding={self.encoding!r}>"
+
+
+def _get_text_stdin(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedReader(_WindowsConsoleReader(STDIN_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stdout(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDOUT_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+def _get_text_stderr(buffer_stream: t.BinaryIO) -> t.TextIO:
+    text_stream = _NonClosingTextIOWrapper(
+        io.BufferedWriter(_WindowsConsoleWriter(STDERR_HANDLE)),
+        "utf-16-le",
+        "strict",
+        line_buffering=True,
+    )
+    return t.cast(t.TextIO, ConsoleStream(text_stream, buffer_stream))
+
+
+_stream_factories: cabc.Mapping[int, t.Callable[[t.BinaryIO], t.TextIO]] = {
+    0: _get_text_stdin,
+    1: _get_text_stdout,
+    2: _get_text_stderr,
+}
+
+
+def _is_console(f: t.TextIO) -> bool:
+    if not hasattr(f, "fileno"):
+        return False
+
+    try:
+        fileno = f.fileno()
+    except (OSError, io.UnsupportedOperation):
+        return False
+
+    handle = msvcrt.get_osfhandle(fileno)
+    return bool(GetConsoleMode(handle, byref(DWORD())))
+
+
+def _get_windows_console_stream(
+    f: t.TextIO, encoding: str | None, errors: str | None
+) -> t.TextIO | None:
+    if (
+        get_buffer is None
+        or encoding not in {"utf-16-le", None}
+        or errors not in {"strict", None}
+        or not _is_console(f)
+    ):
+        return None
+
+    func = _stream_factories.get(f.fileno())
+    if func is None:
+        return None
+
+    b = getattr(f, "buffer", None)
+
+    if b is None:
+        return None
+
+    return func(b)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/core.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..de129ec2ceaa1e77cab696cad672b0a3ca84413d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/core.py
@@ -0,0 +1,3799 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import enum
+import errno
+import inspect
+import os
+import sys
+import typing as t
+from abc import ABC
+from abc import abstractmethod
+from collections import abc
+from collections import Counter
+from contextlib import AbstractContextManager
+from contextlib import contextmanager
+from contextlib import ExitStack
+from functools import update_wrapper
+from gettext import gettext as _
+from gettext import ngettext
+from itertools import repeat
+from types import TracebackType
+
+from . import types
+from ._utils import FLAG_NEEDS_VALUE
+from ._utils import UNSET
+from .exceptions import Abort
+from .exceptions import BadParameter
+from .exceptions import ClickException
+from .exceptions import Exit
+from .exceptions import MissingParameter
+from .exceptions import NoArgsIsHelpError
+from .exceptions import NoSuchCommand
+from .exceptions import UsageError
+from .formatting import HelpFormatter
+from .formatting import join_options
+from .globals import pop_context
+from .globals import push_context
+from .parser import _OptionParser
+from .parser import _split_opt
+from .termui import confirm
+from .termui import prompt
+from .termui import style
+from .utils import _detect_program_name
+from .utils import _expand_args
+from .utils import _make_default_short_help
+from .utils import _PacifyFlushWrapper
+from .utils import echo
+from .utils import make_str
+
+if t.TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from .shell_completion import CompletionItem
+
+F = t.TypeVar("F", bound="t.Callable[..., t.Any]")
+V = t.TypeVar("V")
+
+# Reserved storage name of the automatic help option. No user parameter is
+# expected to claim it.
+_HELP_OPTION_STORAGE_NAME = "_click_default_help"
+
+
+def _complete_visible_commands(
+    ctx: Context, incomplete: str
+) -> cabc.Iterator[tuple[str, Command]]:
+    """List all the subcommands of a group that start with the
+    incomplete value and aren't hidden.
+
+    :param ctx: Invocation context for the group.
+    :param incomplete: Value being completed. May be empty.
+    """
+    multi = t.cast(Group, ctx.command)
+
+    for name in multi.list_commands(ctx):
+        if name.startswith(incomplete):
+            command = multi.get_command(ctx, name)
+
+            if command is not None and not command.hidden:
+                yield name, command
+
+
+def _check_nested_chain(
+    base_command: Group, cmd_name: str, cmd: Command, register: bool = False
+) -> None:
+    if not base_command.chain or not isinstance(cmd, Group):
+        return
+
+    if register:
+        message = (
+            f"It is not possible to add the group {cmd_name!r} to another"
+            f" group {base_command.name!r} that is in chain mode."
+        )
+    else:
+        message = (
+            f"Found the group {cmd_name!r} as subcommand to another group "
+            f" {base_command.name!r} that is in chain mode. This is not supported."
+        )
+
+    raise RuntimeError(message)
+
+
+def _format_deprecated_label(deprecated: bool | str) -> str:
+    """Return the parenthesized deprecation label shown in help text."""
+    label = _("deprecated").upper()
+    if isinstance(deprecated, str):
+        return f"({label}: {deprecated})"
+    return f"({label})"
+
+
+def _format_deprecated_suffix(deprecated: bool | str) -> str:
+    """Return the trailing reason for a ``DeprecationWarning`` message,
+    prefixed with a space, or an empty string when no reason was given.
+    """
+    if isinstance(deprecated, str):
+        return f" {deprecated}"
+    return ""
+
+
+def batch(iterable: cabc.Iterable[V], batch_size: int) -> list[tuple[V, ...]]:
+    return list(zip(*repeat(iter(iterable), batch_size), strict=False))
+
+
+@contextmanager
+def augment_usage_errors(
+    ctx: Context, param: Parameter | None = None
+) -> cabc.Generator[None]:
+    """Context manager that attaches extra information to exceptions."""
+    try:
+        yield
+    except BadParameter as e:
+        if e.ctx is None:
+            e.ctx = ctx
+        if param is not None and e.param is None:
+            e.param = param
+        raise
+    except UsageError as e:
+        if e.ctx is None:
+            e.ctx = ctx
+        raise
+
+
+def iter_params_for_processing(
+    invocation_order: cabc.Sequence[Parameter],
+    declaration_order: cabc.Sequence[Parameter],
+) -> list[Parameter]:
+    """Returns all declared parameters in the order they should be processed.
+
+    The declared parameters are re-shuffled depending on the order in which
+    they were invoked, as well as the eagerness of each parameters.
+
+    The invocation order takes precedence over the declaration order. I.e. the
+    order in which the user provided them to the CLI is respected.
+
+    This behavior and its effect on callback evaluation is detailed at:
+    https://click.palletsprojects.com/en/stable/advanced/#callback-evaluation-order
+    """
+
+    def sort_key(item: Parameter) -> tuple[bool, float]:
+        try:
+            idx: float = invocation_order.index(item)
+        except ValueError:
+            idx = float("inf")
+
+        return not item.is_eager, idx
+
+    return sorted(declaration_order, key=sort_key)
+
+
+class ParameterSource(enum.IntEnum):
+    """This is an :class:`~enum.IntEnum` that indicates the source of a
+    parameter's value.
+
+    Use :meth:`click.Context.get_parameter_source` to get the
+    source for a parameter by name.
+
+    Members are ordered from most explicit to least explicit source.
+    This allows comparison to check if a value was explicitly provided:
+
+    .. code-block:: python
+
+        source = ctx.get_parameter_source("port")
+        if source < click.ParameterSource.DEFAULT_MAP:
+            ...  # value was explicitly set
+
+    .. versionchanged:: 8.3.3
+        Use :class:`~enum.IntEnum` and reorder members from most to
+        least explicit. Supports comparison operators.
+
+    .. versionchanged:: 8.0
+        Use :class:`~enum.Enum` and drop the ``validate`` method.
+
+    .. versionchanged:: 8.0
+        Added the ``PROMPT`` value.
+    """
+
+    PROMPT = enum.auto()
+    """Used a prompt to confirm a default or provide a value."""
+    COMMANDLINE = enum.auto()
+    """The value was provided by the command line args."""
+    ENVIRONMENT = enum.auto()
+    """The value was provided with an environment variable."""
+    DEFAULT_MAP = enum.auto()
+    """Used a default provided by :attr:`Context.default_map`."""
+    DEFAULT = enum.auto()
+    """Used the default specified by the parameter."""
+
+
+class Context:
+    """The context is a special internal object that holds state relevant
+    for the script execution at every single level.  It's normally invisible
+    to commands unless they opt-in to getting access to it.
+
+    The context is useful as it can pass internal objects around and can
+    control special execution features such as reading data from
+    environment variables.
+
+    A context can be used as context manager in which case it will call
+    :meth:`close` on teardown.
+
+    :param command: the command class for this context.
+    :param parent: the parent context.
+    :param info_name: the info name for this invocation.  Generally this
+                      is the most descriptive name for the script or
+                      command.  For the toplevel script it is usually
+                      the name of the script, for commands below that it's
+                      the name of the script.
+    :param obj: an arbitrary object of user data.
+    :param auto_envvar_prefix: the prefix to use for automatic environment
+                               variables.  If this is `None` then reading
+                               from environment variables is disabled.  This
+                               does not affect manually set environment
+                               variables which are always read.
+    :param default_map: a dictionary (like object) with default values
+                        for parameters.
+    :param terminal_width: the width of the terminal.  The default is
+                           inherit from parent context.  If no context
+                           defines the terminal width then auto
+                           detection will be applied.
+    :param max_content_width: the maximum width for content rendered by
+                              Click (this currently only affects help
+                              pages).  This defaults to 80 characters if
+                              not overridden.  In other words: even if the
+                              terminal is larger than that, Click will not
+                              format things wider than 80 characters by
+                              default.  In addition to that, formatters might
+                              add some safety mapping on the right.
+    :param resilient_parsing: if this flag is enabled then Click will
+                              parse without any interactivity or callback
+                              invocation.  Default values will also be
+                              ignored.  This is useful for implementing
+                              things such as completion support.
+    :param allow_extra_args: if this is set to `True` then extra arguments
+                             at the end will not raise an error and will be
+                             kept on the context.  The default is to inherit
+                             from the command.
+    :param allow_interspersed_args: if this is set to `False` then options
+                                    and arguments cannot be mixed.  The
+                                    default is to inherit from the command.
+    :param ignore_unknown_options: instructs click to ignore options it does
+                                   not know and keeps them for later
+                                   processing.
+    :param help_option_names: optionally a list of strings that define how
+                              the default help parameter is named.  The
+                              default is ``['--help']``.
+    :param token_normalize_func: an optional function that is used to
+                                 normalize tokens (options, choices,
+                                 etc.).  This for instance can be used to
+                                 implement case insensitive behavior.
+    :param color: controls if the terminal supports ANSI colors or not.  The
+                  default is autodetection.  This is only needed if ANSI
+                  codes are used in texts that Click prints which is by
+                  default not the case.  This for instance would affect
+                  help output.
+    :param show_default: Show the default value for commands. If this
+        value is not set, it defaults to the value from the parent
+        context. ``Command.show_default`` overrides this default for the
+        specific command.
+
+    .. versionchanged:: 8.2
+        The ``protected_args`` attribute is deprecated and will be removed in
+        Click 9.0. ``args`` will contain remaining unparsed tokens.
+
+    .. versionchanged:: 8.1
+        The ``show_default`` parameter is overridden by
+        ``Command.show_default``, instead of the other way around.
+
+    .. versionchanged:: 8.0
+        The ``show_default`` parameter defaults to the value from the
+        parent context.
+
+    .. versionchanged:: 7.1
+       Added the ``show_default`` parameter.
+
+    .. versionchanged:: 4.0
+        Added the ``color``, ``ignore_unknown_options``, and
+        ``max_content_width`` parameters.
+
+    .. versionchanged:: 3.0
+        Added the ``allow_extra_args`` and ``allow_interspersed_args``
+        parameters.
+
+    .. versionchanged:: 2.0
+        Added the ``resilient_parsing``, ``help_option_names``, and
+        ``token_normalize_func`` parameters.
+    """
+
+    #: The formatter class to create with :meth:`make_formatter`.
+    #:
+    #: .. versionadded:: 8.0
+    formatter_class: type[HelpFormatter] = HelpFormatter
+
+    parent: Context | None
+    command: Command
+    info_name: str | None
+    params: dict[str, t.Any]
+    args: list[str]
+    _protected_args: list[str]
+    _opt_prefixes: set[str]
+    obj: t.Any
+    _meta: dict[str, t.Any]
+    default_map: cabc.MutableMapping[str, t.Any] | None
+    invoked_subcommand: str | None
+    terminal_width: int | None
+    max_content_width: int | None
+    allow_extra_args: bool
+    allow_interspersed_args: bool
+    ignore_unknown_options: bool
+    help_option_names: list[str]
+    token_normalize_func: t.Callable[[str], str] | None
+    resilient_parsing: bool
+    auto_envvar_prefix: str | None
+    color: bool | None
+    show_default: bool | None
+    _close_callbacks: list[t.Callable[[], t.Any]]
+    _depth: int
+    _parameter_source: dict[str, ParameterSource]
+    _param_default_explicit: dict[str, bool]
+    _exit_stack: ExitStack
+
+    def __init__(
+        self,
+        command: Command,
+        parent: Context | None = None,
+        info_name: str | None = None,
+        obj: t.Any | None = None,
+        auto_envvar_prefix: str | None = None,
+        default_map: cabc.MutableMapping[str, t.Any] | None = None,
+        terminal_width: int | None = None,
+        max_content_width: int | None = None,
+        resilient_parsing: bool = False,
+        allow_extra_args: bool | None = None,
+        allow_interspersed_args: bool | None = None,
+        ignore_unknown_options: bool | None = None,
+        help_option_names: list[str] | None = None,
+        token_normalize_func: t.Callable[[str], str] | None = None,
+        color: bool | None = None,
+        show_default: bool | None = None,
+    ) -> None:
+        #: the parent context or `None` if none exists.
+        self.parent = parent
+        #: the :class:`Command` for this context.
+        self.command = command
+        #: the descriptive information name
+        self.info_name = info_name
+        #: Map of parameter names to their parsed values. Parameters
+        #: with ``expose_value=False`` are not stored.
+        self.params = {}
+        #: the leftover arguments.
+        self.args = []
+        #: protected arguments.  These are arguments that are prepended
+        #: to `args` when certain parsing scenarios are encountered but
+        #: must be never propagated to another arguments.  This is used
+        #: to implement nested parsing.
+        self._protected_args = []
+        #: the collected prefixes of the command's options.
+        self._opt_prefixes = set(parent._opt_prefixes) if parent else set()
+
+        if obj is None and parent is not None:
+            obj = parent.obj
+
+        #: the user object stored.
+        self.obj = obj
+        self._meta = getattr(parent, "meta", {})
+
+        #: A dictionary (-like object) with defaults for parameters.
+        if (
+            default_map is None
+            and info_name is not None
+            and parent is not None
+            and parent.default_map is not None
+        ):
+            default_map = parent.default_map.get(info_name)
+
+        self.default_map = default_map
+
+        #: This flag indicates if a subcommand is going to be executed. A
+        #: group callback can use this information to figure out if it's
+        #: being executed directly or because the execution flow passes
+        #: onwards to a subcommand. By default it's None, but it can be
+        #: the name of the subcommand to execute.
+        #:
+        #: If chaining is enabled this will be set to ``'*'`` in case
+        #: any commands are executed.  It is however not possible to
+        #: figure out which ones.  If you require this knowledge you
+        #: should use a :func:`result_callback`.
+        self.invoked_subcommand = None
+
+        if terminal_width is None and parent is not None:
+            terminal_width = parent.terminal_width
+
+        #: The width of the terminal (None is autodetection).
+        self.terminal_width = terminal_width
+
+        if max_content_width is None and parent is not None:
+            max_content_width = parent.max_content_width
+
+        #: The maximum width of formatted content (None implies a sensible
+        #: default which is 80 for most things).
+        self.max_content_width = max_content_width
+
+        if allow_extra_args is None:
+            allow_extra_args = command.allow_extra_args
+
+        #: Indicates if the context allows extra args or if it should
+        #: fail on parsing.
+        #:
+        #: .. versionadded:: 3.0
+        self.allow_extra_args = allow_extra_args
+
+        if allow_interspersed_args is None:
+            allow_interspersed_args = command.allow_interspersed_args
+
+        #: Indicates if the context allows mixing of arguments and
+        #: options or not.
+        #:
+        #: .. versionadded:: 3.0
+        self.allow_interspersed_args = allow_interspersed_args
+
+        if ignore_unknown_options is None:
+            ignore_unknown_options = command.ignore_unknown_options
+
+        #: Instructs click to ignore options that a command does not
+        #: understand and will store it on the context for later
+        #: processing.  This is primarily useful for situations where you
+        #: want to call into external programs.  Generally this pattern is
+        #: strongly discouraged because it's not possibly to losslessly
+        #: forward all arguments.
+        #:
+        #: .. versionadded:: 4.0
+        self.ignore_unknown_options = ignore_unknown_options
+
+        if help_option_names is None:
+            if parent is not None:
+                help_option_names = parent.help_option_names
+            else:
+                help_option_names = ["--help"]
+
+        #: The names for the help options.
+        self.help_option_names = help_option_names
+
+        if token_normalize_func is None and parent is not None:
+            token_normalize_func = parent.token_normalize_func
+
+        #: An optional normalization function for tokens.  This is
+        #: options, choices, commands etc.
+        self.token_normalize_func = token_normalize_func
+
+        #: Indicates if resilient parsing is enabled.  In that case Click
+        #: will do its best to not cause any failures and default values
+        #: will be ignored. Useful for completion.
+        self.resilient_parsing = resilient_parsing
+
+        # If there is no envvar prefix yet, but the parent has one and
+        # the command on this level has a name, we can expand the envvar
+        # prefix automatically.
+        if auto_envvar_prefix is None:
+            if (
+                parent is not None
+                and parent.auto_envvar_prefix is not None
+                and self.info_name is not None
+            ):
+                auto_envvar_prefix = (
+                    f"{parent.auto_envvar_prefix}_{self.info_name.upper()}"
+                )
+        else:
+            auto_envvar_prefix = auto_envvar_prefix.upper()
+
+        if auto_envvar_prefix is not None:
+            auto_envvar_prefix = auto_envvar_prefix.replace("-", "_")
+
+        self.auto_envvar_prefix = auto_envvar_prefix
+
+        if color is None and parent is not None:
+            color = parent.color
+
+        #: Controls if styling output is wanted or not.
+        self.color = color
+
+        if show_default is None and parent is not None:
+            show_default = parent.show_default
+
+        #: Show option default values when formatting help text.
+        self.show_default = show_default
+
+        self._close_callbacks = []
+        self._depth = 0
+        self._parameter_source = {}
+        # Tracks whether the option that currently owns each parameter slot in
+        # :attr:`params` had its ``default`` set explicitly by the user. Used
+        # to tie-break feature-switch groups where multiple options share a
+        # parameter name and both fall back to their default value.
+        # Refs: https://github.com/pallets/click/issues/3403
+        self._param_default_explicit = {}
+        self._exit_stack = ExitStack()
+
+    @property
+    def protected_args(self) -> list[str]:
+        import warnings
+
+        warnings.warn(
+            "'protected_args' is deprecated and will be removed in Click 9.0."
+            " 'args' will contain remaining unparsed tokens.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._protected_args
+
+    def to_info_dict(self) -> dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation. This traverses the entire CLI
+        structure.
+
+        .. code-block:: python
+
+            with Context(cli) as ctx:
+                info = ctx.to_info_dict()
+
+        .. versionadded:: 8.0
+        """
+        return {
+            "command": self.command.to_info_dict(self),
+            "info_name": self.info_name,
+            "allow_extra_args": self.allow_extra_args,
+            "allow_interspersed_args": self.allow_interspersed_args,
+            "ignore_unknown_options": self.ignore_unknown_options,
+            "auto_envvar_prefix": self.auto_envvar_prefix,
+        }
+
+    def __enter__(self) -> Self:
+        self._depth += 1
+        push_context(self)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool | None:
+        self._depth -= 1
+        exit_result: bool | None = None
+        if self._depth == 0:
+            exit_result = self._close_with_exception_info(exc_type, exc_value, tb)
+        pop_context()
+
+        return exit_result
+
+    @contextmanager
+    def scope(self, cleanup: bool = True) -> cabc.Generator[Context]:
+        """This helper method can be used with the context object to promote
+        it to the current thread local (see :func:`get_current_context`).
+        The default behavior of this is to invoke the cleanup functions which
+        can be disabled by setting `cleanup` to `False`.  The cleanup
+        functions are typically used for things such as closing file handles.
+
+        If the cleanup is intended the context object can also be directly
+        used as a context manager.
+
+        Example usage::
+
+            with ctx.scope():
+                assert get_current_context() is ctx
+
+        This is equivalent::
+
+            with ctx:
+                assert get_current_context() is ctx
+
+        .. versionadded:: 5.0
+
+        :param cleanup: controls if the cleanup functions should be run or
+                        not.  The default is to run these functions.  In
+                        some situations the context only wants to be
+                        temporarily pushed in which case this can be disabled.
+                        Nested pushes automatically defer the cleanup.
+        """
+        if not cleanup:
+            self._depth += 1
+        try:
+            with self as rv:
+                yield rv
+        finally:
+            if not cleanup:
+                self._depth -= 1
+
+    @property
+    def meta(self) -> dict[str, t.Any]:
+        """This is a dictionary which is shared with all the contexts
+        that are nested.  It exists so that click utilities can store some
+        state here if they need to.  It is however the responsibility of
+        that code to manage this dictionary well.
+
+        The keys are supposed to be unique dotted strings.  For instance
+        module paths are a good choice for it.  What is stored in there is
+        irrelevant for the operation of click.  However what is important is
+        that code that places data here adheres to the general semantics of
+        the system.
+
+        Example usage::
+
+            LANG_KEY = f'{__name__}.lang'
+
+            def set_language(value):
+                ctx = get_current_context()
+                ctx.meta[LANG_KEY] = value
+
+            def get_language():
+                return get_current_context().meta.get(LANG_KEY, 'en_US')
+
+        .. versionadded:: 5.0
+        """
+        return self._meta
+
+    def make_formatter(self) -> HelpFormatter:
+        """Creates the :class:`~click.HelpFormatter` for the help and
+        usage output.
+
+        To quickly customize the formatter class used without overriding
+        this method, set the :attr:`formatter_class` attribute.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`formatter_class` attribute.
+        """
+        return self.formatter_class(
+            width=self.terminal_width, max_width=self.max_content_width
+        )
+
+    def with_resource(self, context_manager: AbstractContextManager[V]) -> V:
+        """Register a resource as if it were used in a ``with``
+        statement. The resource will be cleaned up when the context is
+        popped.
+
+        Uses :meth:`contextlib.ExitStack.enter_context`. It calls the
+        resource's ``__enter__()`` method and returns the result. When
+        the context is popped, it closes the stack, which calls the
+        resource's ``__exit__()`` method.
+
+        To register a cleanup function for something that isn't a
+        context manager, use :meth:`call_on_close`. Or use something
+        from :mod:`contextlib` to turn it into a context manager first.
+
+        .. code-block:: python
+
+            @click.group()
+            @click.option("--name")
+            @click.pass_context
+            def cli(ctx):
+                ctx.obj = ctx.with_resource(connect_db(name))
+
+        :param context_manager: The context manager to enter.
+        :return: Whatever ``context_manager.__enter__()`` returns.
+
+        .. versionadded:: 8.0
+        """
+        return self._exit_stack.enter_context(context_manager)
+
+    def call_on_close(self, f: t.Callable[..., t.Any]) -> t.Callable[..., t.Any]:
+        """Register a function to be called when the context tears down.
+
+        This can be used to close resources opened during the script
+        execution. Resources that support Python's context manager
+        protocol which would be used in a ``with`` statement should be
+        registered with :meth:`with_resource` instead.
+
+        :param f: The function to execute on teardown.
+        """
+        return self._exit_stack.callback(f)
+
+    def close(self) -> None:
+        """Invoke all close callbacks registered with
+        :meth:`call_on_close`, and exit all context managers entered
+        with :meth:`with_resource`.
+        """
+        self._close_with_exception_info(None, None, None)
+
+    def _close_with_exception_info(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> bool | None:
+        """Unwind the exit stack by calling its :meth:`__exit__` providing the exception
+        information to allow for exception handling by the various resources registered
+        using :meth;`with_resource`
+
+        :return: Whatever ``exit_stack.__exit__()`` returns.
+        """
+        exit_result = self._exit_stack.__exit__(exc_type, exc_value, tb)
+        # In case the context is reused, create a new exit stack.
+        self._exit_stack = ExitStack()
+
+        return exit_result
+
+    @property
+    def command_path(self) -> str:
+        """The computed command path.  This is used for the ``usage``
+        information on the help page.  It's automatically created by
+        combining the info names of the chain of contexts to the root.
+        """
+        rv = ""
+        if self.info_name is not None:
+            rv = self.info_name
+        if self.parent is not None:
+            parent_command_path = [self.parent.command_path]
+
+            if isinstance(self.parent.command, Command):
+                for param in self.parent.command.get_params(self):
+                    parent_command_path.extend(param.get_usage_pieces(self))
+
+            rv = f"{' '.join(parent_command_path)} {rv}"
+        return rv.lstrip()
+
+    def find_root(self) -> Context:
+        """Finds the outermost context."""
+        node = self
+        while node.parent is not None:
+            node = node.parent
+        return node
+
+    def find_object(self, object_type: type[V]) -> V | None:
+        """Finds the closest object of a given type."""
+        node: Context | None = self
+
+        while node is not None:
+            if isinstance(node.obj, object_type):
+                return node.obj
+
+            node = node.parent
+
+        return None
+
+    def ensure_object(self, object_type: type[V]) -> V:
+        """Like :meth:`find_object` but sets the innermost object to a
+        new instance of `object_type` if it does not exist.
+        """
+        rv = self.find_object(object_type)
+        if rv is None:
+            self.obj = rv = object_type()
+        return rv
+
+    def _default_map_has(self, name: str | None) -> bool:
+        """Check if :attr:`default_map` contains a real value for ``name``.
+
+        Returns ``False`` when the key is absent, the map is ``None``,
+        ``name`` is ``None``, or the stored value is the internal
+        :data:`UNSET` sentinel.
+        """
+        return (
+            name is not None
+            and self.default_map is not None
+            and name in self.default_map
+            and self.default_map[name] is not UNSET
+        )
+
+    @t.overload
+    def lookup_default(
+        self, name: str, call: t.Literal[True] = True
+    ) -> t.Any | None: ...
+
+    @t.overload
+    def lookup_default(
+        self, name: str, call: t.Literal[False] = ...
+    ) -> t.Any | t.Callable[[], t.Any] | None: ...
+
+    def lookup_default(self, name: str, call: bool = True) -> t.Any | None:
+        """Get the default for a parameter from :attr:`default_map`.
+
+        :param name: Name of the parameter.
+        :param call: If the default is a callable, call it. Disable to
+            return the callable instead.
+
+        .. versionchanged:: 8.0
+            Added the ``call`` parameter.
+        """
+        if not self._default_map_has(name):
+            return None
+
+        # Assert to make the type checker happy.
+        assert self.default_map is not None
+        value = self.default_map[name]
+
+        if call and callable(value):
+            return value()
+
+        return value
+
+    def fail(self, message: str) -> t.NoReturn:
+        """Aborts the execution of the program with a specific error
+        message.
+
+        :param message: the error message to fail with.
+        """
+        raise UsageError(message, self)
+
+    def abort(self) -> t.NoReturn:
+        """Aborts the script."""
+        raise Abort()
+
+    def exit(self, code: int = 0) -> t.NoReturn:
+        """Exits the application with a given exit code.
+
+        .. versionchanged:: 8.2
+            Callbacks and context managers registered with :meth:`call_on_close`
+            and :meth:`with_resource` are closed before exiting.
+        """
+        self.close()
+        raise Exit(code)
+
+    def get_usage(self) -> str:
+        """Helper method to get formatted usage string for the current
+        context and command.
+        """
+        return self.command.get_usage(self)
+
+    def get_help(self) -> str:
+        """Helper method to get formatted help page for the current
+        context and command.
+        """
+        return self.command.get_help(self)
+
+    def _make_sub_context(self, command: Command) -> Context:
+        """Create a new context of the same type as this context, but
+        for a new command.
+
+        :meta private:
+        """
+        return type(self)(command, info_name=command.name, parent=self)
+
+    @t.overload
+    def invoke(
+        self, callback: t.Callable[..., V], /, *args: t.Any, **kwargs: t.Any
+    ) -> V: ...
+
+    @t.overload
+    def invoke(self, callback: Command, /, *args: t.Any, **kwargs: t.Any) -> t.Any: ...
+
+    def invoke(
+        self, callback: Command | t.Callable[..., V], /, *args: t.Any, **kwargs: t.Any
+    ) -> t.Any | V:
+        """Invokes a command callback in exactly the way it expects.  There
+        are two ways to invoke this method:
+
+        1.  the first argument can be a callback and all other arguments and
+            keyword arguments are forwarded directly to the function.
+        2.  the first argument is a click command object.  In that case all
+            arguments are forwarded as well but proper click parameters
+            (options and click arguments) must be keyword arguments and Click
+            will fill in defaults.
+
+        .. versionchanged:: 8.0
+            All ``kwargs`` are tracked in :attr:`params` so they will be
+            passed if :meth:`forward` is called at multiple levels.
+
+        .. versionchanged:: 3.2
+            A new context is created, and missing arguments use default values.
+        """
+        if isinstance(callback, Command):
+            other_cmd = callback
+
+            if other_cmd.callback is None:
+                raise TypeError(
+                    "The given command does not have a callback that can be invoked."
+                )
+            else:
+                callback = t.cast("t.Callable[..., V]", other_cmd.callback)
+
+            ctx = self._make_sub_context(other_cmd)
+
+            for param in other_cmd.params:
+                if param.name not in kwargs and param.expose_value:
+                    default_value = param.get_default(ctx)
+                    # We explicitly hide the :attr:`UNSET` value to the user, as we
+                    # choose to make it an implementation detail. And because ``invoke``
+                    # has been designed as part of Click public API, we return ``None``
+                    # instead. Refs:
+                    # https://github.com/pallets/click/issues/3066
+                    # https://github.com/pallets/click/issues/3065
+                    # https://github.com/pallets/click/pull/3068
+                    if default_value is UNSET:
+                        default_value = None
+                    kwargs[param.name] = param.type_cast_value(ctx, default_value)
+
+            # Track all kwargs as params, so that forward() will pass
+            # them on in subsequent calls.
+            ctx.params.update(kwargs)
+        else:
+            ctx = self
+
+        with augment_usage_errors(self), ctx:
+            return callback(*args, **kwargs)
+
+    def forward(self, cmd: Command, /, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Similar to :meth:`invoke` but fills in default keyword
+        arguments from the current context if the other command expects
+        it.  This cannot invoke callbacks directly, only other commands.
+
+        .. versionchanged:: 8.0
+            All ``kwargs`` are tracked in :attr:`params` so they will be
+            passed if ``forward`` is called at multiple levels.
+        """
+        # Can only forward to other commands, not direct callbacks.
+        if not isinstance(cmd, Command):
+            raise TypeError("Callback is not a command.")
+
+        for param in self.params:
+            if param not in kwargs:
+                kwargs[param] = self.params[param]
+
+        return self.invoke(cmd, *args, **kwargs)
+
+    def set_parameter_source(self, name: str, source: ParameterSource) -> None:
+        """Set the source of a parameter. This indicates the location
+        from which the value of the parameter was obtained.
+
+        :param name: The name of the parameter.
+        :param source: A member of :class:`~click.core.ParameterSource`.
+        """
+        self._parameter_source[name] = source
+
+    def get_parameter_source(self, name: str) -> ParameterSource | None:
+        """Get the source of a parameter. This indicates the location
+        from which the value of the parameter was obtained.
+
+        This can be useful for determining when a user specified a value
+        on the command line that is the same as the default value. It
+        will be :attr:`~click.core.ParameterSource.DEFAULT` only if the
+        value was actually taken from the default.
+
+        :param name: The name of the parameter.
+        :rtype: ParameterSource
+
+        .. versionchanged:: 8.0
+            Returns ``None`` if the parameter was not provided from any
+            source.
+        """
+        return self._parameter_source.get(name)
+
+
+class Command:
+    """Commands are the basic building block of command line interfaces in
+    Click.  A basic command handles command line parsing and might dispatch
+    more parsing to commands nested below it.
+
+    :param name: the name of the command to use unless a group overrides it.
+    :param context_settings: an optional dictionary with defaults that are
+                             passed to the context object.
+    :param callback: the callback to invoke.  This is optional.
+    :param params: the parameters to register with this command.  This can
+                   be either :class:`Option` or :class:`Argument` objects.
+    :param help: the help string to use for this command.
+    :param epilog: like the help string but it's printed at the end of the
+                   help page after everything else.
+    :param short_help: the short help to use for this command.  This is
+                       shown on the command listing of the parent command.
+    :param add_help_option: by default each command registers a ``--help``
+                            option.  This can be disabled by this parameter.
+    :param no_args_is_help: this controls what happens if no arguments are
+                            provided.  This option is disabled by default.
+                            If enabled this will add ``--help`` as argument
+                            if no arguments are passed
+    :param hidden: hide this command from help outputs.
+    :param deprecated: If ``True`` or non-empty string, issues a message
+                        indicating that the command is deprecated and highlights
+                        its deprecation in --help. The message can be customized
+                        by using a string as the value.
+
+    .. versionchanged:: 8.2
+        This is the base class for all commands, not ``BaseCommand``.
+        ``deprecated`` can be set to a string as well to customize the
+        deprecation message.
+
+    .. versionchanged:: 8.1
+        ``help``, ``epilog``, and ``short_help`` are stored unprocessed,
+        all formatting is done when outputting help text, not at init,
+        and is done even if not using the ``@command`` decorator.
+
+    .. versionchanged:: 8.0
+        Added a ``repr`` showing the command name.
+
+    .. versionchanged:: 7.1
+        Added the ``no_args_is_help`` parameter.
+
+    .. versionchanged:: 2.0
+        Added the ``context_settings`` parameter.
+    """
+
+    #: The context class to create with :meth:`make_context`.
+    #:
+    #: .. versionadded:: 8.0
+    context_class: type[Context] = Context
+
+    #: the default for the :attr:`Context.allow_extra_args` flag.
+    allow_extra_args = False
+
+    #: the default for the :attr:`Context.allow_interspersed_args` flag.
+    allow_interspersed_args = True
+
+    #: the default for the :attr:`Context.ignore_unknown_options` flag.
+    ignore_unknown_options = False
+
+    name: str | None
+    context_settings: cabc.MutableMapping[str, t.Any]
+    callback: t.Callable[..., t.Any] | None
+    params: list[Parameter]
+    help: str | None
+    epilog: str | None
+    options_metavar: str | None
+    short_help: str | None
+    add_help_option: bool
+    _help_option: Option | None
+    no_args_is_help: bool
+    hidden: bool
+    deprecated: bool | str
+
+    def __init__(
+        self,
+        name: str | None,
+        context_settings: cabc.MutableMapping[str, t.Any] | None = None,
+        callback: t.Callable[..., t.Any] | None = None,
+        params: list[Parameter] | None = None,
+        help: str | None = None,
+        epilog: str | None = None,
+        short_help: str | None = None,
+        options_metavar: str | None = "[OPTIONS]",
+        add_help_option: bool = True,
+        no_args_is_help: bool = False,
+        hidden: bool = False,
+        deprecated: bool | str = False,
+    ) -> None:
+        #: the name the command thinks it has.  Upon registering a command
+        #: on a :class:`Group` the group will default the command name
+        #: with this information.  You should instead use the
+        #: :class:`Context`\'s :attr:`~Context.info_name` attribute.
+        self.name = name
+
+        if context_settings is None:
+            context_settings = {}
+
+        #: an optional dictionary with defaults passed to the context.
+        self.context_settings = context_settings
+
+        #: the callback to execute when the command fires.  This might be
+        #: `None` in which case nothing happens.
+        self.callback = callback
+        #: the list of parameters for this command in the order they
+        #: should show up in the help page and execute.  Eager parameters
+        #: will automatically be handled before non eager ones.
+        self.params = params or []
+        self.help = help
+        self.epilog = epilog
+        self.options_metavar = options_metavar
+        self.short_help = short_help
+        self.add_help_option = add_help_option
+        self._help_option = None
+        self.no_args_is_help = no_args_is_help
+        self.hidden = hidden
+        self.deprecated = deprecated
+
+    def to_info_dict(self, ctx: Context) -> dict[str, t.Any]:
+        return {
+            "name": self.name,
+            "params": [param.to_info_dict() for param in self.get_params(ctx)],
+            "help": self.help,
+            "epilog": self.epilog,
+            "short_help": self.short_help,
+            "hidden": self.hidden,
+            "deprecated": self.deprecated,
+        }
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.name}>"
+
+    def get_usage(self, ctx: Context) -> str:
+        """Formats the usage line into a string and returns it.
+
+        Calls :meth:`format_usage` internally.
+        """
+        formatter = ctx.make_formatter()
+        self.format_usage(ctx, formatter)
+        return formatter.getvalue().rstrip("\n")
+
+    def get_params(self, ctx: Context) -> list[Parameter]:
+        params = self.params
+        help_option = self.get_help_option(ctx)
+
+        if help_option is not None:
+            params = [*params, help_option]
+
+        if __debug__:
+            import warnings
+
+            opts = [opt for param in params for opt in param.opts]
+            opts_counter = Counter(opts)
+            duplicate_opts = (opt for opt, count in opts_counter.items() if count > 1)
+
+            for duplicate_opt in duplicate_opts:
+                warnings.warn(
+                    (
+                        f"The parameter {duplicate_opt} is used more than once. "
+                        "Remove its duplicate as parameters should be unique."
+                    ),
+                    stacklevel=3,
+                )
+
+            # Options may deliberately share a storage name to compete for
+            # the same value (feature switches), but an argument sharing a
+            # name silently overwrites the other parameter's value.
+            names_counter = Counter(param.name for param in params)
+            duplicate_names = (
+                name for name, count in names_counter.items() if count > 1
+            )
+
+            for duplicate_name in duplicate_names:
+                sharers = [param for param in params if param.name == duplicate_name]
+
+                if help_option in sharers:
+                    warnings.warn(
+                        (
+                            f"The name {duplicate_name!r} is reserved for the "
+                            "automatic help option. Give the parameter a "
+                            "different name."
+                        ),
+                        stacklevel=3,
+                    )
+                elif any(isinstance(param, Argument) for param in sharers):
+                    warnings.warn(
+                        (
+                            f"The name {duplicate_name!r} is used by an argument "
+                            "and another parameter. They will overwrite each "
+                            "other's value during parsing. Give each parameter "
+                            "a unique name."
+                        ),
+                        stacklevel=3,
+                    )
+
+        return params
+
+    def format_usage(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the usage line into the formatter.
+
+        This is a low-level method called by :meth:`get_usage`.
+        """
+        pieces = self.collect_usage_pieces(ctx)
+        formatter.write_usage(ctx.command_path, " ".join(pieces))
+
+    def collect_usage_pieces(self, ctx: Context) -> list[str]:
+        """Returns all the pieces that go into the usage line and returns
+        it as a list of strings.
+        """
+        rv = [self.options_metavar] if self.options_metavar else []
+
+        for param in self.get_params(ctx):
+            rv.extend(param.get_usage_pieces(ctx))
+
+        return rv
+
+    def get_help_option_names(self, ctx: Context) -> list[str]:
+        """Returns the names for the help option.
+
+        Drops duplicates and names already reserved by another parameter. Order of
+        :attr:`Context.help_option_names` is preserved, so the result is stable.
+
+        .. versionchanged:: 8.5.0
+            Names keep their declaration order.
+        """
+        all_names = dict.fromkeys(ctx.help_option_names)
+        for param in self.params:
+            for name in (*param.opts, *param.secondary_opts):
+                all_names.pop(name, None)
+        return list(all_names)
+
+    def get_help_option(self, ctx: Context) -> Option | None:
+        """Returns the help option object.
+
+        Skipped if :attr:`add_help_option` is ``False``.
+
+        .. versionchanged:: 8.5.0
+            The help option stores its value under the reserved name
+            ``_click_default_help``, so a parameter named ``help`` no
+            longer breaks parsing.
+
+        .. versionchanged:: 8.1.8
+            The help option is now cached to avoid creating it multiple times.
+        """
+        help_option_names = self.get_help_option_names(ctx)
+
+        if not help_option_names or not self.add_help_option:
+            return None
+
+        # Cache the help option object in private _help_option attribute to
+        # avoid creating it multiple times. Not doing this will break the
+        # callback ordering by iter_params_for_processing(), which relies on
+        # object comparison.
+        if self._help_option is None:
+            # Avoid circular import.
+            from .decorators import help_option
+
+            # The help option never exposes its value, so it uses a reserved
+            # storage name, keeping it clear of user parameters (like an
+            # argument named "help") that would otherwise clobber its value.
+            help_option(*help_option_names, _HELP_OPTION_STORAGE_NAME)(self)
+            self._help_option = self.params.pop()  # type: ignore[assignment]
+
+        return self._help_option
+
+    def make_parser(self, ctx: Context) -> _OptionParser:
+        """Creates the underlying option parser for this command."""
+        parser = _OptionParser(ctx)
+        for param in self.get_params(ctx):
+            param.add_to_parser(parser, ctx)
+        return parser
+
+    def get_help(self, ctx: Context) -> str:
+        """Formats the help into a string and returns it.
+
+        Calls :meth:`format_help` internally.
+        """
+        formatter = ctx.make_formatter()
+        self.format_help(ctx, formatter)
+        return formatter.getvalue().rstrip("\n")
+
+    def get_short_help_str(self, limit: int = 45) -> str:
+        """Gets short help for the command or makes it by shortening the
+        long help string.
+        """
+        if self.short_help:
+            text = inspect.cleandoc(self.short_help)
+        elif self.help:
+            text = _make_default_short_help(self.help, limit)
+        else:
+            text = ""
+
+        if self.deprecated:
+            text = f"{_(text)} {_format_deprecated_label(self.deprecated)}"
+
+        return text.strip()
+
+    def format_help(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the help into the formatter if it exists.
+
+        This is a low-level method called by :meth:`get_help`.
+
+        This calls the following methods:
+
+        -   :meth:`format_usage`
+        -   :meth:`format_help_text`
+        -   :meth:`format_arguments`
+        -   :meth:`format_options`
+        -   :meth:`format_epilog`
+        """
+        self.format_usage(ctx, formatter)
+        self.format_help_text(ctx, formatter)
+        self.format_arguments(ctx, formatter)
+        self.format_options(ctx, formatter)
+        self.format_epilog(ctx, formatter)
+
+    def format_help_text(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the help text to the formatter if it exists."""
+        if self.help is not None:
+            # truncate the help text to the first form feed
+            text = inspect.cleandoc(self.help).partition("\f")[0]
+        else:
+            text = ""
+
+        if self.deprecated:
+            label = _format_deprecated_label(self.deprecated)
+            text = f"{_(text)} {label}" if text else label
+
+        if text:
+            formatter.write_paragraph()
+
+            with formatter.indentation():
+                formatter.write_text(text)
+
+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes all the options into the formatter if they exist."""
+        opts = []
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            if rv is not None and not isinstance(param, Argument):
+                opts.append(rv)
+
+        if opts:
+            with formatter.section(_("Options")):
+                formatter.write_dl(opts)
+
+    def format_arguments(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the arguments that have a help record into the formatter."""
+        args = []
+        for param in self.get_params(ctx):
+            rv = param.get_help_record(ctx)
+            if rv is not None and isinstance(param, Argument):
+                args.append(rv)
+
+        if args:
+            with formatter.section(_("Positional arguments")):
+                formatter.write_dl(args)
+
+    def format_epilog(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Writes the epilog into the formatter if it exists."""
+        if self.epilog:
+            epilog = inspect.cleandoc(self.epilog)
+            formatter.write_paragraph()
+
+            with formatter.indentation():
+                formatter.write_text(epilog)
+
+    def make_context(
+        self,
+        info_name: str | None,
+        args: list[str],
+        parent: Context | None = None,
+        **extra: t.Any,
+    ) -> Context:
+        """This function when given an info name and arguments will kick
+        off the parsing and create a new :class:`Context`.  It does not
+        invoke the actual command callback though.
+
+        To quickly customize the context class used without overriding
+        this method, set the :attr:`context_class` attribute.
+
+        :param info_name: the info name for this invocation.  Generally this
+                          is the most descriptive name for the script or
+                          command.  For the toplevel script it's usually
+                          the name of the script, for commands below it's
+                          the name of the command.
+        :param args: the arguments to parse as list of strings.
+        :param parent: the parent context if available.
+        :param extra: extra keyword arguments forwarded to the context
+                      constructor.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`context_class` attribute.
+        """
+        for key, value in self.context_settings.items():
+            if key not in extra:
+                extra[key] = value
+
+        ctx = self.context_class(self, info_name=info_name, parent=parent, **extra)
+
+        with ctx.scope(cleanup=False):
+            self.parse_args(ctx, args)
+        return ctx
+
+    def parse_args(self, ctx: Context, args: list[str]) -> list[str]:
+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
+            raise NoArgsIsHelpError(ctx)
+
+        parser = self.make_parser(ctx)
+        opts, args, param_order = parser.parse_args(args=args)
+
+        for param in iter_params_for_processing(param_order, self.get_params(ctx)):
+            _, args = param.handle_parse_result(ctx, opts, args)
+
+        # We now have all parameters' values into `ctx.params`, but the data may contain
+        # the `UNSET` sentinel.
+        # Convert `UNSET` to `None` to ensure that the user doesn't see `UNSET`.
+        #
+        # Waiting until after the initial parse to convert allows us to treat `UNSET`
+        # more like a missing value when multiple params use the same name.
+        # Refs:
+        # https://github.com/pallets/click/issues/3071
+        # https://github.com/pallets/click/pull/3079
+        for name, value in ctx.params.items():
+            if value is UNSET:
+                ctx.params[name] = None
+
+        if args and not ctx.allow_extra_args and not ctx.resilient_parsing:
+            ctx.fail(
+                ngettext(
+                    "Got unexpected extra argument ({args})",
+                    "Got unexpected extra arguments ({args})",
+                    len(args),
+                ).format(args=" ".join(map(str, args)))
+            )
+
+        ctx.args = args
+        ctx._opt_prefixes.update(parser._opt_prefixes)
+        return args
+
+    def invoke(self, ctx: Context) -> t.Any:
+        """Given a context, this invokes the attached callback (if it exists)
+        in the right way.
+        """
+        if self.deprecated:
+            message = _(
+                "DeprecationWarning: The command {name!r} is deprecated.{extra_message}"
+            ).format(
+                name=self.name,
+                extra_message=_format_deprecated_suffix(self.deprecated),
+            )
+            echo(style(message, fg="red"), err=True)
+
+        if self.callback is not None:
+            return ctx.invoke(self.callback, **ctx.params)
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> list[CompletionItem]:
+        """Return a list of completions for the incomplete value. Looks
+        at the names of options and chained multi-commands.
+
+        Any command could be part of a chained multi-command, so sibling
+        commands are valid at any point during command completion.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        results: list[CompletionItem] = []
+
+        if incomplete and not incomplete[0].isalnum():
+            for param in self.get_params(ctx):
+                if (
+                    not isinstance(param, Option)
+                    or param.hidden
+                    or (
+                        not param.multiple
+                        and ctx.get_parameter_source(param.name)
+                        is ParameterSource.COMMANDLINE
+                    )
+                ):
+                    continue
+
+                results.extend(
+                    CompletionItem(name, help=param.help)
+                    for name in [*param.opts, *param.secondary_opts]
+                    if name.startswith(incomplete)
+                )
+
+        while ctx.parent is not None:
+            ctx = ctx.parent
+
+            if isinstance(ctx.command, Group) and ctx.command.chain:
+                results.extend(
+                    CompletionItem(name, help=command.get_short_help_str())
+                    for name, command in _complete_visible_commands(ctx, incomplete)
+                    if name not in ctx._protected_args
+                )
+
+        return results
+
+    @t.overload
+    def main(
+        self,
+        args: cabc.Sequence[str] | None = None,
+        prog_name: str | None = None,
+        complete_var: str | None = None,
+        standalone_mode: t.Literal[True] = True,
+        **extra: t.Any,
+    ) -> t.NoReturn: ...
+
+    @t.overload
+    def main(
+        self,
+        args: cabc.Sequence[str] | None = None,
+        prog_name: str | None = None,
+        complete_var: str | None = None,
+        standalone_mode: bool = ...,
+        **extra: t.Any,
+    ) -> t.Any: ...
+
+    def main(
+        self,
+        args: cabc.Sequence[str] | None = None,
+        prog_name: str | None = None,
+        complete_var: str | None = None,
+        standalone_mode: bool = True,
+        windows_expand_args: bool = True,
+        **extra: t.Any,
+    ) -> t.Any:
+        """This is the way to invoke a script with all the bells and
+        whistles as a command line application.  This will always terminate
+        the application after a call.  If this is not wanted, ``SystemExit``
+        needs to be caught.
+
+        This method is also available by directly calling the instance of
+        a :class:`Command`.
+
+        :param args: the arguments that should be used for parsing.  If not
+                     provided, ``sys.argv[1:]`` is used.
+        :param prog_name: the program name that should be used.  By default
+                          the program name is constructed by taking the file
+                          name from ``sys.argv[0]``.
+        :param complete_var: the environment variable that controls the
+                             bash completion support.  The default is
+                             ``"_<prog_name>_COMPLETE"`` with prog_name in
+                             uppercase.
+        :param standalone_mode: the default behavior is to invoke the script
+                                in standalone mode.  Click will then
+                                handle exceptions and convert them into
+                                error messages and the function will never
+                                return but shut down the interpreter.  If
+                                this is set to `False` they will be
+                                propagated to the caller and the return
+                                value of this function is the return value
+                                of :meth:`invoke`.
+        :param windows_expand_args: Expand glob patterns, user dir, and
+            env vars in command line args on Windows.
+        :param extra: extra keyword arguments are forwarded to the context
+                      constructor.  See :class:`Context` for more information.
+
+        .. versionchanged:: 8.0.1
+            Added the ``windows_expand_args`` parameter to allow
+            disabling command line arg expansion on Windows.
+
+        .. versionchanged:: 8.0
+            When taking arguments from ``sys.argv`` on Windows, glob
+            patterns, user dir, and env vars are expanded.
+
+        .. versionchanged:: 3.0
+           Added the ``standalone_mode`` parameter.
+        """
+        if args is None:
+            args = sys.argv[1:]
+
+            if os.name == "nt" and windows_expand_args:
+                args = _expand_args(args)
+        else:
+            args = list(args)
+
+        if prog_name is None:
+            prog_name = _detect_program_name()
+
+        # Process shell completion requests and exit early.
+        self._main_shell_completion(extra, prog_name, complete_var)
+
+        try:
+            try:
+                with self.make_context(prog_name, args, **extra) as ctx:
+                    rv = self.invoke(ctx)
+                    if not standalone_mode:
+                        return rv
+                    # it's not safe to `ctx.exit(rv)` here!
+                    # note that `rv` may actually contain data like "1" which
+                    # has obvious effects
+                    # more subtle case: `rv=[None, None]` can come out of
+                    # chained commands which all returned `None` -- so it's not
+                    # even always obvious that `rv` indicates success/failure
+                    # by its truthiness/falsiness
+                    ctx.exit()
+            except (EOFError, KeyboardInterrupt) as e:
+                echo(file=sys.stderr)
+                raise Abort() from e
+            except ClickException as e:
+                if not standalone_mode:
+                    raise
+                e.show()
+                sys.exit(e.exit_code)
+            except OSError as e:
+                if e.errno == errno.EPIPE:
+                    sys.stdout = t.cast(t.TextIO, _PacifyFlushWrapper(sys.stdout))
+                    sys.stderr = t.cast(t.TextIO, _PacifyFlushWrapper(sys.stderr))
+                    sys.exit(1)
+                else:
+                    raise
+        except Exit as e:
+            if standalone_mode:
+                sys.exit(e.exit_code)
+            else:
+                # in non-standalone mode, return the exit code
+                # note that this is only reached if `self.invoke` above raises
+                # an Exit explicitly -- thus bypassing the check there which
+                # would return its result
+                # the results of non-standalone execution may therefore be
+                # somewhat ambiguous: if there are codepaths which lead to
+                # `ctx.exit(1)` and to `return 1`, the caller won't be able to
+                # tell the difference between the two
+                return e.exit_code
+        except Abort:
+            if not standalone_mode:
+                raise
+            echo(_("Aborted!"), file=sys.stderr)
+            sys.exit(1)
+
+    def _main_shell_completion(
+        self,
+        ctx_args: cabc.MutableMapping[str, t.Any],
+        prog_name: str,
+        complete_var: str | None = None,
+    ) -> None:
+        """Check if the shell is asking for tab completion, process
+        that, then exit early. Called from :meth:`main` before the
+        program is invoked.
+
+        :param prog_name: Name of the executable in the shell.
+        :param complete_var: Name of the environment variable that holds
+            the completion instruction. Defaults to
+            ``_{PROG_NAME}_COMPLETE``.
+
+        .. versionchanged:: 8.2.0
+            Dots (``.``) in ``prog_name`` are replaced with underscores (``_``).
+        """
+        if complete_var is None:
+            complete_name = prog_name.replace("-", "_").replace(".", "_")
+            complete_var = f"_{complete_name}_COMPLETE".upper()
+
+        instruction = os.environ.get(complete_var)
+
+        if not instruction:
+            return
+
+        from .shell_completion import shell_complete
+
+        rv = shell_complete(self, ctx_args, prog_name, complete_var, instruction)
+        sys.exit(rv)
+
+    def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:
+        """Alias for :meth:`main`."""
+        return self.main(*args, **kwargs)
+
+
+class _FakeSubclassCheck(type):
+    def __subclasscheck__(cls, subclass: type) -> bool:
+        return issubclass(subclass, cls.__bases__[0])
+
+    def __instancecheck__(cls, instance: t.Any) -> bool:
+        return isinstance(instance, cls.__bases__[0])
+
+
+class _BaseCommand(Command, metaclass=_FakeSubclassCheck):
+    """
+    .. deprecated:: 8.2
+        Will be removed in Click 9.0. Use ``Command`` instead.
+    """
+
+
+class Group(Command):
+    """A group is a command that nests other commands (or more groups).
+
+    :param name: The name of the group command.
+    :param commands: Map names to :class:`Command` objects. Can be a list, which
+        will use :attr:`Command.name` as the keys.
+    :param invoke_without_command: Invoke the group's callback even if a
+        subcommand is not given.
+    :param no_args_is_help: If no arguments are given, show the group's help and
+        exit. Defaults to the opposite of ``invoke_without_command``.
+    :param subcommand_metavar: How to represent the subcommand argument in help.
+        The default will represent whether ``chain`` is set or not.
+    :param chain: Allow passing more than one subcommand argument. After parsing
+        a command's arguments, if any arguments remain another command will be
+        matched, and so on.
+    :param result_callback: A function to call after the group's and
+        subcommand's callbacks. The value returned by the subcommand is passed.
+        If ``chain`` is enabled, the value will be a list of values returned by
+        all the commands. If ``invoke_without_command`` is enabled, the value
+        will be the value returned by the group's callback, or an empty list if
+        ``chain`` is enabled.
+    :param kwargs: Other arguments passed to :class:`Command`.
+
+    .. versionchanged:: 8.0
+        The ``commands`` argument can be a list of command objects.
+
+    .. versionchanged:: 8.2
+        Merged with and replaces the ``MultiCommand`` base class.
+    """
+
+    allow_extra_args = True
+    allow_interspersed_args = False
+
+    #: If set, this is used by the group's :meth:`command` decorator
+    #: as the default :class:`Command` class. This is useful to make all
+    #: subcommands use a custom command class.
+    #:
+    #: .. versionadded:: 8.0
+    command_class: type[Command] | None = None
+
+    #: If set, this is used by the group's :meth:`group` decorator
+    #: as the default :class:`Group` class. This is useful to make all
+    #: subgroups use a custom group class.
+    #:
+    #: If set to the special value :class:`type` (literally
+    #: ``group_class = type``), this group's class will be used as the
+    #: default class. This makes a custom group class continue to make
+    #: custom groups.
+    #:
+    #: .. versionadded:: 8.0
+    group_class: type[Group | type] | None = None
+    # Literal[type] isn't valid, so use Type[type]
+
+    commands: cabc.MutableMapping[str, Command]
+    invoke_without_command: bool
+    subcommand_metavar: str
+    chain: bool
+    _result_callback: t.Callable[..., t.Any] | None
+
+    def __init__(
+        self,
+        name: str | None = None,
+        commands: cabc.MutableMapping[str, Command]
+        | cabc.Sequence[Command]
+        | None = None,
+        invoke_without_command: bool = False,
+        no_args_is_help: bool | None = None,
+        subcommand_metavar: str | None = None,
+        chain: bool = False,
+        result_callback: t.Callable[..., t.Any] | None = None,
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(name, **kwargs)
+
+        if commands is None:
+            commands = {}
+        elif isinstance(commands, abc.Sequence):
+            commands = {c.name: c for c in commands if c.name is not None}
+
+        #: The registered subcommands by their exported names.
+        self.commands = commands
+
+        if no_args_is_help is None:
+            no_args_is_help = not invoke_without_command
+
+        self.no_args_is_help = no_args_is_help
+        self.invoke_without_command = invoke_without_command
+
+        if subcommand_metavar is None:
+            # When the group can run without a subcommand, the leading command
+            # token is optional, so wrap it in brackets to reflect that.
+            if chain:
+                if invoke_without_command:
+                    subcommand_metavar = "[COMMAND1] [ARGS]... [COMMAND2 [ARGS]...]..."
+                else:
+                    subcommand_metavar = "COMMAND1 [ARGS]... [COMMAND2 [ARGS]...]..."
+            elif invoke_without_command:
+                subcommand_metavar = "[COMMAND] [ARGS]..."
+            else:
+                subcommand_metavar = "COMMAND [ARGS]..."
+
+        self.subcommand_metavar = subcommand_metavar
+        self.chain = chain
+        # The result callback that is stored. This can be set or
+        # overridden with the :func:`result_callback` decorator.
+        self._result_callback = result_callback
+
+        if self.chain:
+            for param in self.params:
+                if isinstance(param, Argument) and not param.required:
+                    raise RuntimeError(
+                        "A group in chain mode cannot have optional arguments."
+                    )
+
+    def to_info_dict(self, ctx: Context) -> dict[str, t.Any]:
+        info_dict = super().to_info_dict(ctx)
+        commands = {}
+
+        for name in self.list_commands(ctx):
+            command = self.get_command(ctx, name)
+
+            if command is None:
+                continue
+
+            sub_ctx = ctx._make_sub_context(command)
+
+            with sub_ctx.scope(cleanup=False):
+                commands[name] = command.to_info_dict(sub_ctx)
+
+        info_dict.update(commands=commands, chain=self.chain)
+        return info_dict
+
+    def add_command(self, cmd: Command, name: str | None = None) -> None:
+        """Registers another :class:`Command` with this group.  If the name
+        is not provided, the name of the command is used.
+        """
+        name = name or cmd.name
+        if name is None:
+            raise TypeError("Command has no name.")
+        _check_nested_chain(self, name, cmd, register=True)
+        self.commands[name] = cmd
+
+    @t.overload
+    def command(self, __func: t.Callable[..., t.Any]) -> Command: ...
+
+    @t.overload
+    def command(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Command]: ...
+
+    def command(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Command] | Command:
+        """A shortcut decorator for declaring and attaching a command to
+        the group. This takes the same arguments as :func:`command` and
+        immediately registers the created command with this group by
+        calling :meth:`add_command`.
+
+        To customize the command class used, set the
+        :attr:`command_class` attribute.
+
+        .. versionchanged:: 8.1
+            This decorator can be applied without parentheses.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`command_class` attribute.
+        """
+        from .decorators import command
+
+        func: t.Callable[..., t.Any] | None = None
+
+        if args and callable(args[0]):
+            assert len(args) == 1 and not kwargs, (
+                "Use 'command(**kwargs)(callable)' to provide arguments."
+            )
+            (func,) = args
+            args = ()
+
+        if self.command_class and kwargs.get("cls") is None:
+            kwargs["cls"] = self.command_class
+
+        def decorator(f: t.Callable[..., t.Any]) -> Command:
+            cmd: Command = command(*args, **kwargs)(f)
+            self.add_command(cmd)
+            return cmd
+
+        if func is not None:
+            return decorator(func)
+
+        return decorator
+
+    @t.overload
+    def group(self, __func: t.Callable[..., t.Any]) -> Group: ...
+
+    @t.overload
+    def group(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Group]: ...
+
+    def group(
+        self, *args: t.Any, **kwargs: t.Any
+    ) -> t.Callable[[t.Callable[..., t.Any]], Group] | Group:
+        """A shortcut decorator for declaring and attaching a group to
+        the group. This takes the same arguments as :func:`group` and
+        immediately registers the created group with this group by
+        calling :meth:`add_command`.
+
+        To customize the group class used, set the :attr:`group_class`
+        attribute.
+
+        .. versionchanged:: 8.1
+            This decorator can be applied without parentheses.
+
+        .. versionchanged:: 8.0
+            Added the :attr:`group_class` attribute.
+        """
+        from .decorators import group
+
+        func: t.Callable[..., t.Any] | None = None
+
+        if args and callable(args[0]):
+            assert len(args) == 1 and not kwargs, (
+                "Use 'group(**kwargs)(callable)' to provide arguments."
+            )
+            (func,) = args
+            args = ()
+
+        if self.group_class is not None and kwargs.get("cls") is None:
+            if self.group_class is type:
+                kwargs["cls"] = type(self)
+            else:
+                kwargs["cls"] = self.group_class
+
+        def decorator(f: t.Callable[..., t.Any]) -> Group:
+            cmd: Group = group(*args, **kwargs)(f)
+            self.add_command(cmd)
+            return cmd
+
+        if func is not None:
+            return decorator(func)
+
+        return decorator
+
+    def result_callback(self, replace: bool = False) -> t.Callable[[F], F]:
+        """Adds a result callback to the command.  By default if a
+        result callback is already registered this will chain them but
+        this can be disabled with the `replace` parameter.  The result
+        callback is invoked with the return value of the subcommand
+        (or the list of return values from all subcommands if chaining
+        is enabled) as well as the parameters as they would be passed
+        to the main callback.
+
+        Example::
+
+            @click.group()
+            @click.option('-i', '--input', default=23)
+            def cli(input):
+                return 42
+
+            @cli.result_callback()
+            def process_result(result, input):
+                return result + input
+
+        :param replace: if set to `True` an already existing result
+                        callback will be removed.
+
+        .. versionchanged:: 8.0
+            Renamed from ``resultcallback``.
+
+        .. versionadded:: 3.0
+        """
+
+        def decorator(f: F) -> F:
+            old_callback = self._result_callback
+
+            if old_callback is None or replace:
+                self._result_callback = f
+                return f
+
+            def function(value: t.Any, /, *args: t.Any, **kwargs: t.Any) -> t.Any:
+                inner = old_callback(value, *args, **kwargs)
+                return f(inner, *args, **kwargs)
+
+            self._result_callback = rv = update_wrapper(t.cast(F, function), f)
+            return rv  # type: ignore[return-value]
+
+        return decorator
+
+    def get_command(self, ctx: Context, cmd_name: str) -> Command | None:
+        """Given a context and a command name, this returns a :class:`Command`
+        object if it exists or returns ``None``.
+        """
+        return self.commands.get(cmd_name)
+
+    def list_commands(self, ctx: Context) -> list[str]:
+        """Returns a list of subcommand names in the order they should appear."""
+        return sorted(self.commands)
+
+    def collect_usage_pieces(self, ctx: Context) -> list[str]:
+        rv = super().collect_usage_pieces(ctx)
+        rv.append(self.subcommand_metavar)
+        return rv
+
+    def format_options(self, ctx: Context, formatter: HelpFormatter) -> None:
+        super().format_options(ctx, formatter)
+        self.format_commands(ctx, formatter)
+
+    def format_commands(self, ctx: Context, formatter: HelpFormatter) -> None:
+        """Extra format methods for multi methods that adds all the commands
+        after the options.
+        """
+        commands = []
+        for subcommand in self.list_commands(ctx):
+            cmd = self.get_command(ctx, subcommand)
+            # What is this, the tool lied about a command.  Ignore it
+            if cmd is None:
+                continue
+            if cmd.hidden:
+                continue
+
+            commands.append((subcommand, cmd))
+
+        # allow for 3 times the default spacing
+        if len(commands):
+            limit = formatter.width - 6 - max(len(cmd[0]) for cmd in commands)
+
+            rows = []
+            for subcommand, cmd in commands:
+                help = cmd.get_short_help_str(limit)
+                rows.append((subcommand, help))
+
+            if rows:
+                with formatter.section(_("Commands")):
+                    formatter.write_dl(rows)
+
+    def parse_args(self, ctx: Context, args: list[str]) -> list[str]:
+        if not args and self.no_args_is_help and not ctx.resilient_parsing:
+            raise NoArgsIsHelpError(ctx)
+
+        rest = super().parse_args(ctx, args)
+
+        if self.chain:
+            ctx._protected_args = rest
+            ctx.args = []
+        elif rest:
+            ctx._protected_args, ctx.args = rest[:1], rest[1:]
+
+        return ctx.args
+
+    def invoke(self, ctx: Context) -> t.Any:
+        def _process_result(value: t.Any) -> t.Any:
+            if self._result_callback is not None:
+                value = ctx.invoke(self._result_callback, value, **ctx.params)
+            return value
+
+        if not ctx._protected_args:
+            if self.invoke_without_command:
+                # No subcommand was invoked, so the result callback is
+                # invoked with the group return value for regular
+                # groups, or an empty list for chained groups.
+                with ctx:
+                    rv = super().invoke(ctx)
+                    return _process_result([] if self.chain else rv)
+            ctx.fail(_("Missing command."))
+
+        # Fetch args back out
+        args = [*ctx._protected_args, *ctx.args]
+        ctx.args = []
+        ctx._protected_args = []
+
+        # If we're not in chain mode, we only allow the invocation of a
+        # single command but we also inform the current context about the
+        # name of the command to invoke.
+        if not self.chain:
+            # Make sure the context is entered so we do not clean up
+            # resources until the result processor has worked.
+            with ctx:
+                cmd_name, cmd, args = self.resolve_command(ctx, args)
+                assert cmd is not None
+                ctx.invoked_subcommand = cmd_name
+                super().invoke(ctx)
+                sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)
+                with sub_ctx:
+                    return _process_result(sub_ctx.command.invoke(sub_ctx))
+
+        # In chain mode we create the contexts step by step, but after the
+        # base command has been invoked.  Because at that point we do not
+        # know the subcommands yet, the invoked subcommand attribute is
+        # set to ``*`` to inform the command that subcommands are executed
+        # but nothing else.
+        with ctx:
+            ctx.invoked_subcommand = "*" if args else None
+            super().invoke(ctx)
+
+            # Otherwise we make every single context and invoke them in a
+            # chain.  In that case the return value to the result processor
+            # is the list of all invoked subcommand's results.
+            contexts = []
+            while args:
+                cmd_name, cmd, args = self.resolve_command(ctx, args)
+                assert cmd is not None
+                sub_ctx = cmd.make_context(
+                    cmd_name,
+                    args,
+                    parent=ctx,
+                    allow_extra_args=True,
+                    allow_interspersed_args=False,
+                )
+                contexts.append(sub_ctx)
+                args, sub_ctx.args = sub_ctx.args, []
+
+            rv = []
+            for sub_ctx in contexts:
+                with sub_ctx:
+                    rv.append(sub_ctx.command.invoke(sub_ctx))
+            return _process_result(rv)
+
+    def resolve_command(
+        self, ctx: Context, args: list[str]
+    ) -> tuple[str | None, Command | None, list[str]]:
+        cmd_name = make_str(args[0])
+
+        # Get the command
+        cmd = self.get_command(ctx, cmd_name)
+
+        # If we can't find the command but there is a normalization
+        # function available, we try with that one.
+        if cmd is None and ctx.token_normalize_func is not None:
+            cmd_name = ctx.token_normalize_func(cmd_name)
+            cmd = self.get_command(ctx, cmd_name)
+
+        # If we don't find the command we want to show an error message
+        # to the user that it was not provided.  However, there is
+        # something else we should do: if the first argument looks like
+        # an option we want to kick off parsing again for arguments to
+        # resolve things like --help which now should go to the main
+        # place.
+        if cmd is None and not ctx.resilient_parsing:
+            if _split_opt(cmd_name)[0]:
+                self.parse_args(ctx, args)
+            raise NoSuchCommand(cmd_name, possibilities=self.commands, ctx=ctx)
+        return cmd_name if cmd else None, cmd, args[1:]
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> list[CompletionItem]:
+        """Return a list of completions for the incomplete value. Looks
+        at the names of options, subcommands, and chained
+        multi-commands.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        results = [
+            CompletionItem(name, help=command.get_short_help_str())
+            for name, command in _complete_visible_commands(ctx, incomplete)
+        ]
+        results.extend(super().shell_complete(ctx, incomplete))
+        return results
+
+
+class _MultiCommand(Group, metaclass=_FakeSubclassCheck):
+    """
+    .. deprecated:: 8.2
+        Will be removed in Click 9.0. Use ``Group`` instead.
+    """
+
+
+class CommandCollection(Group):
+    """A :class:`Group` that looks up subcommands on other groups. If a command
+    is not found on this group, each registered source is checked in order.
+    Parameters on a source are not added to this group, and a source's callback
+    is not invoked when invoking its commands. In other words, this "flattens"
+    commands in many groups into this one group.
+
+    :param name: The name of the group command.
+    :param sources: A list of :class:`Group` objects to look up commands from.
+    :param kwargs: Other arguments passed to :class:`Group`.
+
+    .. versionchanged:: 8.2
+        This is a subclass of ``Group``. Commands are looked up first on this
+        group, then each of its sources.
+    """
+
+    sources: list[Group]
+
+    def __init__(
+        self,
+        name: str | None = None,
+        sources: list[Group] | None = None,
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(name, **kwargs)
+        #: The list of registered groups.
+        self.sources = sources or []
+
+    def add_source(self, group: Group) -> None:
+        """Add a group as a source of commands."""
+        self.sources.append(group)
+
+    def get_command(self, ctx: Context, cmd_name: str) -> Command | None:
+        rv = super().get_command(ctx, cmd_name)
+
+        if rv is not None:
+            return rv
+
+        for source in self.sources:
+            rv = source.get_command(ctx, cmd_name)
+
+            if rv is not None:
+                if self.chain:
+                    _check_nested_chain(self, cmd_name, rv)
+
+                return rv
+
+        return None
+
+    def list_commands(self, ctx: Context) -> list[str]:
+        rv: set[str] = set(super().list_commands(ctx))
+
+        for source in self.sources:
+            rv.update(source.list_commands(ctx))
+
+        return sorted(rv)
+
+
+def _check_iter(value: cabc.Iterable[V]) -> cabc.Iterator[V]:
+    """Check if the value is iterable but not a string. Raises a type
+    error, or return an iterator over the value.
+    """
+    if isinstance(value, str):
+        raise TypeError
+
+    return iter(value)
+
+
+class Parameter(ABC):
+    r"""A parameter to a command comes in two versions: they are either
+    :class:`Option`\s or :class:`Argument`\s.  Other subclasses are currently
+    not supported by design as some of the internals for parsing are
+    intentionally not finalized.
+
+    Some settings are supported by both options and arguments.
+
+    :param param_decls: the parameter declarations for this option or
+                        argument.  This is a list of flags or argument
+                        names.
+    :param type: the type that should be used.  Either a :class:`ParamType`
+                 or a Python type.  The latter is converted into the former
+                 automatically if supported.
+    :param required: controls if this is optional or not.
+    :param default: the default value if omitted.  This can also be a callable,
+                    in which case it's invoked when the default is needed
+                    without any arguments.
+    :param callback: A function to further process or validate the value
+        after type conversion. It is called as ``f(ctx, param, value)``
+        and must return the value. It is called for all sources,
+        including prompts.
+    :param nargs: the number of arguments to match.  If not ``1`` the return
+                  value is a tuple instead of single value.  The default for
+                  nargs is ``1`` (except if the type is a tuple, then it's
+                  the arity of the tuple). If ``nargs=-1``, all remaining
+                  parameters are collected.
+    :param metavar: how the value is represented in the help page.
+    :param expose_value: if this is `True` then the value is passed onwards
+                         to the command callback and stored on the context,
+                         otherwise it's skipped.
+    :param is_eager: eager values are processed before non eager ones.  This
+                     should not be set for arguments or it will inverse the
+                     order of processing.
+    :param envvar: environment variable(s) that are used to provide a default value for
+        this parameter. This can be a string or a sequence of strings. If a sequence is
+        given, only the first non-empty environment variable is used for the parameter.
+    :param shell_complete: A function that returns custom shell
+        completions. Used instead of the param's type completion if
+        given. Takes ``ctx, param, incomplete`` and must return a list
+        of :class:`~click.shell_completion.CompletionItem` or a list of
+        strings.
+    :param deprecated: If ``True`` or non-empty string, issues a message
+                        indicating that the argument is deprecated and highlights
+                        its deprecation in --help. The message can be customized
+                        by using a string as the value. A deprecated parameter
+                        cannot be required, a ValueError will be raised otherwise.
+
+    .. versionchanged:: 8.2.0
+        Introduction of ``deprecated``.
+
+    .. versionchanged:: 8.2
+        Adding duplicate parameter names to a :class:`~click.core.Command` will
+        result in a ``UserWarning`` being shown.
+
+    .. versionchanged:: 8.2
+        Adding duplicate parameter names to a :class:`~click.core.Command` will
+        result in a ``UserWarning`` being shown.
+
+    .. versionchanged:: 8.0
+        ``process_value`` validates required parameters and bounded
+        ``nargs``, and invokes the parameter callback before returning
+        the value. This allows the callback to validate prompts.
+        ``full_process_value`` is removed.
+
+    .. versionchanged:: 8.0
+        ``autocompletion`` is renamed to ``shell_complete`` and has new
+        semantics described above. The old name is deprecated and will
+        be removed in 8.1, until then it will be wrapped to match the
+        new requirements.
+
+    .. versionchanged:: 8.0
+        For ``multiple=True, nargs>1``, the default must be a list of
+        tuples.
+
+    .. versionchanged:: 8.0
+        Setting a default is no longer required for ``nargs>1``, it will
+        default to ``None``. ``multiple=True`` or ``nargs=-1`` will
+        default to ``()``.
+
+    .. versionchanged:: 7.1
+        Empty environment variables are ignored rather than taking the
+        empty string value. This makes it possible for scripts to clear
+        variables if they can't unset them.
+
+    .. versionchanged:: 2.0
+        Changed signature for parameter callback to also be passed the
+        parameter. The old callback format will still work, but it will
+        raise a warning to give you a chance to migrate the code easier.
+    """
+
+    param_type_name = "parameter"
+
+    name: str
+    opts: list[str]
+    secondary_opts: list[str]
+    # `Parameter.type` is annotated in `__init__` to avoid confusing mypy
+    required: bool
+    callback: t.Callable[[Context, Parameter, t.Any], t.Any] | None
+    nargs: int
+    multiple: bool
+    expose_value: bool
+    default: t.Any | t.Callable[[], t.Any] | None
+    _default_explicit: bool
+    is_eager: bool
+    metavar: str | None
+    envvar: str | cabc.Sequence[str] | None
+    _custom_shell_complete: (
+        t.Callable[[Context, Parameter, str], list[CompletionItem] | list[str]] | None
+    )
+    deprecated: bool | str
+
+    def __init__(
+        self,
+        param_decls: cabc.Sequence[str] | None = None,
+        type: types.ParamType[t.Any] | t.Any | None = None,
+        required: bool = False,
+        # XXX The default historically embed two concepts:
+        # - the declaration of a Parameter object carrying the default (handy to
+        #   arbitrage the default value of coupled Parameters sharing the same
+        #   self.name, like flag options),
+        # - and the actual value of the default.
+        # It is confusing and is the source of many issues discussed in:
+        # https://github.com/pallets/click/pull/3030
+        # In the future, we might think of splitting it in two, not unlike
+        # Option.is_flag and Option.flag_value: we could have something like
+        # Parameter.is_default and Parameter.default_value.
+        default: t.Any | t.Callable[[], t.Any] | None = UNSET,
+        callback: t.Callable[[Context, Parameter, t.Any], t.Any] | None = None,
+        nargs: int | None = None,
+        multiple: bool = False,
+        metavar: str | None = None,
+        expose_value: bool = True,
+        is_eager: bool = False,
+        envvar: str | cabc.Sequence[str] | None = None,
+        shell_complete: t.Callable[
+            [Context, Parameter, str], list[CompletionItem] | list[str]
+        ]
+        | None = None,
+        deprecated: bool | str = False,
+    ) -> None:
+        self.name, self.opts, self.secondary_opts = self._parse_decls(
+            param_decls or (), expose_value
+        )
+        self.type: types.ParamType[t.Any] = types.convert_type(type, default)
+
+        # Default nargs to what the type tells us if we have that
+        # information available.
+        if nargs is None:
+            if self.type.is_composite:
+                nargs = self.type.arity
+            else:
+                nargs = 1
+
+        self.required = required
+        self.callback = callback
+        self.nargs = nargs
+        self.multiple = multiple
+        self.expose_value = expose_value
+        self.default = default
+        # Whether the user passed ``default`` explicitly to the constructor.
+        # Captured before any auto-derived default (like ``False`` for boolean
+        # flags in :class:`Option`) replaces the :data:`UNSET` sentinel, so it
+        # remains ``False`` when the default was inferred rather than chosen.
+        # Refs: https://github.com/pallets/click/issues/3403
+        self._default_explicit = default is not UNSET
+        self.is_eager = is_eager
+        self.metavar = metavar
+        self.envvar = envvar
+        self._custom_shell_complete = shell_complete
+        self.deprecated = deprecated
+
+        if __debug__:
+            if self.type.is_composite and nargs != self.type.arity:
+                raise ValueError(
+                    f"'nargs' must be {self.type.arity} (or None) for"
+                    f" type {self.type!r}, but it was {nargs}."
+                )
+
+            if required and deprecated:
+                raise ValueError(
+                    f"The {self.param_type_name} '{self.human_readable_name}' "
+                    "is deprecated and still required. A deprecated "
+                    f"{self.param_type_name} cannot be required."
+                )
+
+    @staticmethod
+    def _hide_unset(value: t.Any) -> t.Any:
+        """Present the internal :data:`UNSET` sentinel as ``None`` at a boundary that
+        exposes a parameter's value (introspection, prompts), keeping the sentinel an
+        implementation detail.
+        """
+        return None if value is UNSET else value
+
+    def to_info_dict(self) -> dict[str, t.Any]:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation.
+
+        Use :meth:`click.Context.to_info_dict` to traverse the entire
+        CLI structure.
+
+        .. versionchanged:: 8.3.0
+            Returns ``None`` for the :attr:`default` if it was not set.
+
+        .. versionadded:: 8.0
+        """
+        return {
+            "name": self.name,
+            "param_type_name": self.param_type_name,
+            "opts": self.opts,
+            "secondary_opts": self.secondary_opts,
+            "type": self.type.to_info_dict(),
+            "required": self.required,
+            "nargs": self.nargs,
+            "multiple": self.multiple,
+            "default": self._hide_unset(self.default),
+            "envvar": self.envvar,
+        }
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} {self.name}>"
+
+    @abstractmethod
+    def _parse_decls(
+        self, decls: cabc.Sequence[str], expose_value: bool
+    ) -> tuple[str, list[str], list[str]]: ...
+
+    @property
+    def human_readable_name(self) -> str:
+        """Returns the human readable name of this parameter.  This is the
+        same as the name for options, but the metavar for arguments.
+        """
+        return self.name
+
+    def make_metavar(self, ctx: Context) -> str:
+        if self.metavar is not None:
+            return self.metavar
+
+        metavar = self.type.get_metavar(param=self, ctx=ctx)
+
+        if metavar is None:
+            metavar = self.type.name.upper()
+
+        if self.nargs != 1:
+            metavar += "..."
+
+        return metavar
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: t.Literal[True] = True
+    ) -> t.Any | None: ...
+
+    @t.overload
+    def get_default(
+        self, ctx: Context, call: bool = ...
+    ) -> t.Any | t.Callable[[], t.Any] | None: ...
+
+    def get_default(
+        self, ctx: Context, call: bool = True
+    ) -> t.Any | t.Callable[[], t.Any] | None:
+        """Get the default for the parameter. Tries
+        :meth:`Context.lookup_default` first, then the local default.
+
+        :param ctx: Current context.
+        :param call: If the default is a callable, call it. Disable to
+            return the callable instead.
+
+        .. versionchanged:: 8.0.2
+            Type casting is no longer performed when getting a default.
+
+        .. versionchanged:: 8.0.1
+            Type casting can fail in resilient parsing mode. Invalid
+            defaults will not prevent showing help text.
+
+        .. versionchanged:: 8.0
+            Looks at ``ctx.default_map`` first.
+
+        .. versionchanged:: 8.0
+            Added the ``call`` parameter.
+        """
+        value = ctx.lookup_default(self.name, call=False)
+
+        if value is None and not ctx._default_map_has(self.name):
+            value = self.default
+
+        if call and callable(value):
+            value = value()
+
+        return value
+
+    @abstractmethod
+    def add_to_parser(self, parser: _OptionParser, ctx: Context) -> None: ...
+
+    def consume_value(
+        self, ctx: Context, opts: cabc.Mapping[str, t.Any]
+    ) -> tuple[t.Any, ParameterSource]:
+        """Returns the parameter value produced by the parser.
+
+        If the parser did not produce a value from user input, the value is either
+        sourced from the environment variable, the default map, or the parameter's
+        default value. In that order of precedence.
+
+        If no value is found, an internal sentinel value is returned.
+
+        :meta private:
+        """
+        # Collect from the parse the value passed by the user to the CLI.
+        value = opts.get(self.name, UNSET)
+        # If the value is set, it means it was sourced from the command line by the
+        # parser, otherwise it left unset by default.
+        source = (
+            ParameterSource.COMMANDLINE
+            if value is not UNSET
+            else ParameterSource.DEFAULT
+        )
+
+        if value is UNSET:
+            envvar_value = self.value_from_envvar(ctx)
+            if envvar_value is not None:
+                value = envvar_value
+                source = ParameterSource.ENVIRONMENT
+
+        if value is UNSET:
+            default_map_value = ctx.lookup_default(self.name)
+            if default_map_value is not None or ctx._default_map_has(self.name):
+                value = default_map_value
+                source = ParameterSource.DEFAULT_MAP
+
+                # A string from default_map must be split for multi-value
+                # parameters, matching value_from_envvar behavior.
+                if isinstance(value, str) and self.nargs != 1:
+                    value = self.type.split_envvar_value(value)
+
+        if value is UNSET:
+            default_value = self.get_default(ctx)
+            if default_value is not UNSET:
+                value = default_value
+                source = ParameterSource.DEFAULT
+
+        return value, source
+
+    def type_cast_value(self, ctx: Context, value: t.Any) -> t.Any:
+        """Convert and validate a value against the parameter's
+        :attr:`type`, :attr:`multiple`, and :attr:`nargs`.
+        """
+        if value is None:
+            if self.multiple or self.nargs == -1:
+                return ()
+            else:
+                return value
+
+        def check_iter(value: t.Any) -> cabc.Iterator[t.Any]:
+            try:
+                return _check_iter(value)
+            except TypeError:
+                # This should only happen when passing in args manually,
+                # the parser should construct an iterable when parsing
+                # the command line.
+                raise BadParameter(
+                    _("Value must be an iterable."), ctx=ctx, param=self
+                ) from None
+
+        # Define the conversion function based on nargs and type.
+
+        if self.nargs == 1 or self.type.is_composite:
+
+            def convert(value: t.Any) -> t.Any:
+                return self.type(value, param=self, ctx=ctx)
+
+        elif self.nargs == -1:
+
+            def convert(value: t.Any) -> t.Any:  # tuple[t.Any, ...]
+                return tuple(self.type(x, self, ctx) for x in check_iter(value))
+
+        else:  # nargs > 1
+
+            def convert(value: t.Any) -> t.Any:  # tuple[t.Any, ...]
+                value = tuple(check_iter(value))
+
+                if len(value) != self.nargs:
+                    raise BadParameter(
+                        ngettext(
+                            "Takes {nargs} values but 1 was given.",
+                            "Takes {nargs} values but {len} were given.",
+                            len(value),
+                        ).format(nargs=self.nargs, len=len(value)),
+                        ctx=ctx,
+                        param=self,
+                    )
+
+                return tuple(self.type(x, self, ctx) for x in value)
+
+        if self.multiple:
+            return tuple(convert(x) for x in check_iter(value))
+
+        return convert(value)
+
+    def value_is_missing(self, value: t.Any) -> bool:
+        """A value is considered missing if:
+
+        - it is :attr:`UNSET`,
+        - or if it is an empty sequence while the parameter is suppose to have
+          non-single value (i.e. :attr:`nargs` is not ``1`` or :attr:`multiple` is
+          set).
+
+        :meta private:
+        """
+        if value is UNSET:
+            return True
+
+        if (self.nargs != 1 or self.multiple) and value == ():
+            return True
+
+        return False
+
+    def process_value(self, ctx: Context, value: t.Any) -> t.Any:
+        """Process the value of this parameter:
+
+        1. Type cast the value using :meth:`type_cast_value`.
+        2. Check if the value is missing (see: :meth:`value_is_missing`), and raise
+           :exc:`MissingParameter` if it is required.
+        3. If a :attr:`callback` is set, call it to have the value replaced by the
+           result of the callback. If the value was not set, the callback receive
+           ``None``. This keep the legacy behavior as it was before the introduction of
+           the :attr:`UNSET` sentinel.
+
+        :meta private:
+        """
+        # shelter `type_cast_value` from ever seeing an `UNSET` value by handling the
+        # cases in which `UNSET` gets special treatment explicitly at this layer
+        #
+        # Refs:
+        # https://github.com/pallets/click/issues/3069
+        if value is UNSET:
+            if self.multiple or self.nargs == -1:
+                value = ()
+        else:
+            value = self.type_cast_value(ctx, value)
+
+        if self.required and self.value_is_missing(value):
+            raise MissingParameter(ctx=ctx, param=self)
+
+        if self.callback is not None:
+            # Legacy case: UNSET is not exposed directly to the callback, but converted
+            # to None.
+            if value is UNSET:
+                value = None
+
+            # Search for parameters with UNSET values in the context.
+            unset_keys = {k: None for k, v in ctx.params.items() if v is UNSET}
+            # No UNSET values, call the callback as usual.
+            if not unset_keys:
+                value = self.callback(ctx, self, value)
+
+            # Legacy case: provide a temporarily manipulated context to the callback
+            # to hide UNSET values as None.
+            #
+            # Refs:
+            # https://github.com/pallets/click/issues/3136
+            # https://github.com/pallets/click/pull/3137
+            else:
+                # Add another layer to the context stack to clearly hint that the
+                # context is temporarily modified.
+                with ctx:
+                    # Update the context parameters to replace UNSET with None.
+                    ctx.params.update(unset_keys)
+                    # Feed these fake context parameters to the callback.
+                    value = self.callback(ctx, self, value)
+                    # Restore the UNSET values in the context parameters.
+                    ctx.params.update(
+                        {
+                            k: UNSET
+                            for k in unset_keys
+                            # Only restore keys that are present and still None, in case
+                            # the callback modified other parameters.
+                            if k in ctx.params and ctx.params[k] is None
+                        }
+                    )
+
+        return value
+
+    def resolve_envvar_value(self, ctx: Context) -> str | None:
+        """Returns the value found in the environment variable(s) attached to this
+        parameter.
+
+        Environment variables values are `always returned as strings
+        <https://docs.python.org/3/library/os.html#os.environ>`_.
+
+        This method returns ``None`` if:
+
+        - the :attr:`envvar` property is not set on the :class:`Parameter`,
+        - the environment variable is not found in the environment,
+        - the variable is found in the environment but its value is empty (i.e. the
+          environment variable is present but has an empty string).
+
+        If :attr:`envvar` is setup with multiple environment variables,
+        then only the first non-empty value is returned.
+
+        .. caution::
+
+            The raw value extracted from the environment is not normalized and is
+            returned as-is. Any normalization or reconciliation is performed later by
+            the :class:`Parameter`'s :attr:`type`.
+
+        :meta private:
+        """
+        if not self.envvar:
+            return None
+
+        if isinstance(self.envvar, str):
+            rv = os.environ.get(self.envvar)
+
+            if rv:
+                return rv
+        else:
+            for envvar in self.envvar:
+                rv = os.environ.get(envvar)
+
+                # Return the first non-empty value of the list of environment variables.
+                if rv:
+                    return rv
+                # Else, absence of value is interpreted as an environment variable that
+                # is not set, so proceed to the next one.
+
+        return None
+
+    def value_from_envvar(self, ctx: Context) -> str | cabc.Sequence[str] | None:
+        """Process the raw environment variable string for this parameter.
+
+        Returns the string as-is or splits it into a sequence of strings if the
+        parameter is expecting multiple values (i.e. its :attr:`nargs` property is set
+        to a value other than ``1``).
+
+        :meta private:
+        """
+        rv = self.resolve_envvar_value(ctx)
+
+        if rv is not None and self.nargs != 1:
+            return self.type.split_envvar_value(rv)
+
+        return rv
+
+    def handle_parse_result(
+        self, ctx: Context, opts: cabc.Mapping[str, t.Any], args: list[str]
+    ) -> tuple[t.Any, list[str]]:
+        """Process the value produced by the parser from user input.
+
+        Always process the value through the Parameter's :attr:`type`, wherever it
+        comes from.
+
+        If the parameter is deprecated, this method warn the user about it. But only if
+        the value has been explicitly set by the user (and as such, is not coming from
+        a default).
+
+        :meta private:
+        """
+        # Capture the slot's existing state before we mutate
+        # ``_parameter_source`` so the write decision below can compare our
+        # incoming source against the source of the option that already wrote
+        # the slot (if any).
+        existing_value = ctx.params.get(self.name, UNSET)
+        existing_source = ctx.get_parameter_source(self.name)
+        existing_default_explicit = ctx._param_default_explicit.get(self.name, False)
+
+        with augment_usage_errors(ctx, param=self):
+            value, source = self.consume_value(ctx, opts)
+
+            # Record the source before processing so eager callbacks and type
+            # conversion can inspect it. Restored after arbitration if this
+            # option loses a feature-switch group.
+            ctx.set_parameter_source(self.name, source)
+
+            # Display a deprecation warning if necessary.
+            if (
+                self.deprecated
+                and value is not UNSET
+                and source < ParameterSource.DEFAULT_MAP
+            ):
+                message = _(
+                    "DeprecationWarning: The {param_type} {name!r} is deprecated."
+                    "{extra_message}"
+                ).format(
+                    param_type=self.param_type_name,
+                    name=self.human_readable_name,
+                    extra_message=_format_deprecated_suffix(self.deprecated),
+                )
+                echo(style(message, fg="red"), err=True)
+
+            # Process the value through the parameter's type.
+            try:
+                value = self.process_value(ctx, value)
+            except Exception:
+                if not ctx.resilient_parsing:
+                    raise
+                # In resilient parsing mode, we do not want to fail the command if the
+                # value is incompatible with the parameter type, so we reset the value
+                # to UNSET, which will be interpreted as a missing value.
+                value = UNSET
+
+        # Arbitrate the slot when several parameters target the same variable
+        # name (feature-switch groups). See: https://github.com/pallets/click/issues/3403
+        slot_empty = existing_value is UNSET
+        more_explicit = existing_source is not None and source < existing_source
+        same_source = existing_source is not None and source == existing_source
+        auto_would_downgrade_explicit = (
+            same_source
+            and source == ParameterSource.DEFAULT
+            and existing_default_explicit
+            and not self._default_explicit
+        )
+        is_winner = (
+            slot_empty
+            or more_explicit
+            or (same_source and not auto_would_downgrade_explicit)
+        )
+
+        if is_winner:
+            if self.expose_value:
+                ctx.params[self.name] = value
+                ctx._param_default_explicit[self.name] = self._default_explicit
+        elif existing_source is not None:
+            # Lost arbitration; restore the winning option's source.
+            ctx.set_parameter_source(self.name, existing_source)
+        # else: ctx.params[self.name] was populated by code that bypassed
+        # handle_parse_result (from another option's callback for example). Keep
+        # the provisional source recorded before process_value so downstream
+        # lookups don't return ``None``.
+
+        return value, args
+
+    def get_help_record(self, ctx: Context) -> tuple[str, str] | None:
+        return None
+
+    def get_usage_pieces(self, ctx: Context) -> list[str]:
+        return []
+
+    def get_error_hint(self, ctx: Context | None) -> str:
+        """Get a stringified version of the param for use in error messages to
+        indicate which param caused the error.
+
+        .. versionchanged:: 8.4.0
+            ``ctx`` can be ``None``.
+        """
+        hint_list = self.opts or [self.human_readable_name]
+        return " / ".join(f"'{x}'" for x in hint_list)
+
+    def shell_complete(self, ctx: Context, incomplete: str) -> list[CompletionItem]:
+        """Return a list of completions for the incomplete value. If a
+        ``shell_complete`` function was given during init, it is used.
+        Otherwise, the :attr:`type`
+        :meth:`~click.types.ParamType[t.Any].shell_complete` function is used.
+
+        :param ctx: Invocation context for this command.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        if self._custom_shell_complete is not None:
+            results = self._custom_shell_complete(ctx, self, incomplete)
+
+            if results and isinstance(results[0], str):
+                from click.shell_completion import CompletionItem
+
+                results = [CompletionItem(c) for c in results]
+
+            return t.cast("list[CompletionItem]", results)
+
+        return self.type.shell_complete(ctx, self, incomplete)
+
+
+class Option(Parameter):
+    """Options are usually optional values on the command line and
+    have some extra features that arguments don't have.
+
+    All other parameters are passed onwards to the parameter constructor.
+
+    :param show_default: Show the default value for this option in its
+        help text. Values are not shown by default, unless
+        :attr:`Context.show_default` is ``True``. If this value is a
+        string, it shows that string in parentheses instead of the
+        actual value. This is particularly useful for dynamic options.
+        For single option boolean flags, the default remains hidden if
+        its value is ``False``.
+    :param show_envvar: Controls if an environment variable should be
+        shown on the help page and error messages.
+        Normally, environment variables are not shown.
+    :param prompt: If set to ``True`` or a non empty string then the
+        user will be prompted for input. If set to ``True`` the prompt
+        will be the option name capitalized. A deprecated option cannot be
+        prompted.
+    :param confirmation_prompt: Prompt a second time to confirm the
+        value if it was prompted for. Can be set to a string instead of
+        ``True`` to customize the message.
+    :param prompt_required: If set to ``False``, the user will be
+        prompted for input only when the option was specified as a flag
+        without a value.
+    :param hide_input: If this is ``True`` then the input on the prompt
+        will be hidden from the user. This is useful for password input.
+    :param is_flag: forces this option to act as a flag.  The default is
+                    auto detection.
+    :param flag_value: which value should be used for this flag if it's
+                       enabled.  This is set to a boolean automatically if
+                       the option string contains a slash to mark two options.
+    :param multiple: if this is set to `True` then the argument is accepted
+                     multiple times and recorded.  This is similar to ``nargs``
+                     in how it works but supports arbitrary number of
+                     arguments.
+    :param count: this flag makes an option increment an integer.
+    :param allow_from_autoenv: if this is enabled then the value of this
+                               parameter will be pulled from an environment
+                               variable in case a prefix is defined on the
+                               context.
+    :param help: the help string.
+    :param hidden: hide this option from help outputs.
+    :param attrs: Other command arguments described in :class:`Parameter`.
+
+    .. versionchanged:: 8.4.0
+        Non-basic ``flag_value`` types (not ``str``, ``int``, ``float``, or
+        ``bool``) are passed through unchanged instead of being stringified.
+        Previously, ``type=click.UNPROCESSED`` was required to preserve them.
+
+    .. versionchanged:: 8.2
+        ``envvar`` used with ``flag_value`` will always use the ``flag_value``,
+        previously it would use the value of the environment variable.
+
+    .. versionchanged:: 8.1
+        Help text indentation is cleaned here instead of only in the
+        ``@option`` decorator.
+
+    .. versionchanged:: 8.1
+        The ``show_default`` parameter overrides
+        ``Context.show_default``.
+
+    .. versionchanged:: 8.1
+        The default of a single option boolean flag is not shown if the
+        default value is ``False``.
+
+    .. versionchanged:: 8.0.1
+        ``type`` is detected from ``flag_value`` if given, for basic Python
+        types (``str``, ``int``, ``float``, ``bool``).
+    """
+
+    param_type_name = "option"
+
+    prompt: str | None
+    confirmation_prompt: bool | str
+    prompt_required: bool
+    hide_input: bool
+    hidden: bool
+
+    _flag_needs_value: bool
+    is_flag: bool
+    flag_value: t.Any
+    type: types.ParamType[t.Any]
+    default: t.Any | t.Callable[[], t.Any] | None
+
+    count: bool
+    allow_from_autoenv: bool
+    help: str | None
+    show_default: bool | str | None
+    show_choices: bool
+    show_envvar: bool
+
+    def __init__(
+        self,
+        param_decls: cabc.Sequence[str] | None = None,
+        show_default: bool | str | None = None,
+        prompt: bool | str = False,
+        confirmation_prompt: bool | str = False,
+        prompt_required: bool = True,
+        hide_input: bool = False,
+        is_flag: bool | None = None,
+        flag_value: t.Any = UNSET,
+        multiple: bool = False,
+        count: bool = False,
+        allow_from_autoenv: bool = True,
+        type: types.ParamType[t.Any] | t.Any | None = None,
+        help: str | None = None,
+        hidden: bool = False,
+        show_choices: bool = True,
+        show_envvar: bool = False,
+        deprecated: bool | str = False,
+        **attrs: t.Any,
+    ) -> None:
+        if help:
+            help = inspect.cleandoc(help)
+
+        super().__init__(
+            param_decls, type=type, multiple=multiple, deprecated=deprecated, **attrs
+        )
+
+        # Phase 1: prompt-related attributes. ``_infer_flag_kind`` reads ``self.prompt``
+        # and ``self.prompt_required`` so this must run first.
+        if prompt is True:
+            if not self.name:
+                raise TypeError("'name' is required with 'prompt=True'.")
+
+            prompt_text = self.name.replace("_", " ").capitalize()
+        elif prompt is False:
+            prompt_text = None
+        else:
+            prompt_text = prompt
+
+        if deprecated:
+            label = _format_deprecated_label(deprecated)
+            help = f"{help} {label}" if help else label
+
+        self.prompt = prompt_text
+        self.confirmation_prompt = confirmation_prompt
+        self.prompt_required = prompt_required
+        self.hide_input = hide_input
+        self.hidden = hidden
+
+        # Phase 2: flag-kind inference.
+        self.is_flag, self._flag_needs_value = self._infer_flag_kind(
+            is_flag, flag_value
+        )
+
+        # Phase 3: type inference. Override the type set by :meth:`Parameter.__init__`
+        # when this option is a flag or a count.
+        self.type = self._pick_type(type, flag_value, count, self.is_flag)
+
+        # Phase 4: store the raw ``flag_value`` and ``count`` settings.
+        # ``self.flag_value`` and ``self.default`` deliberately keep the :data:`UNSET`
+        # sentinel when the user didn't pass them. Auto-derived values are resolved
+        # lazily in :meth:`_resolve_lazy_default` and :attr:`flag_activation_value`.
+        # Keeping the raw values means ``is UNSET`` reliably answers "did the user pass
+        # this?": #3403 needs it for arbitration, and any future feature needing the
+        # same distinction can reuse it without reintroducing parallel "was it
+        # explicit?" tracking.
+        self.flag_value = flag_value
+        self.count = count
+        if count and self.default is UNSET:
+            self.default = 0
+
+        self.allow_from_autoenv = allow_from_autoenv
+        self.help = help
+        self.show_default = show_default
+        self.show_choices = show_choices
+        self.show_envvar = show_envvar
+
+        # Phase 5: validate. Raises on illegal kwarg combinations.
+        self._validate(prompt, deprecated)
+
+    @property
+    def is_bool_flag(self) -> bool:
+        """``True`` when this option is a flag with a boolean type.
+
+        Derived from :attr:`is_flag` and :attr:`type`; computed on access so it cannot
+        drift if a subclass replaces :attr:`type` after construction.
+        """
+        return self.is_flag and isinstance(self.type, types.BoolParamType)
+
+    @property
+    def flag_activation_value(self) -> t.Any:
+        """Value the function receives when this flag is activated on the command line.
+
+        Resolves a missing :attr:`flag_value` to ``True`` for actual flag options and
+        ``None`` otherwise. Used by the parser bridge (:meth:`add_to_parser`) and the
+        runtime (:meth:`consume_value`) so :attr:`flag_value` can keep the :data:`UNSET`
+        sentinel for "did the user pass one?" introspection.
+        """
+        if self.flag_value is UNSET:
+            return True if self.is_flag else None
+        return self.flag_value
+
+    def _infer_flag_kind(
+        self, is_flag: bool | None, flag_value: t.Any
+    ) -> tuple[bool, bool]:
+        """Resolve ``is_flag`` and the parser hint ``_flag_needs_value``.
+
+        Returns ``(is_flag, flag_needs_value)``, where ``_flag_needs_value`` tells the
+        parser this option is a flag that cannot be used standalone and needs a value.
+        The parser uses it to decide whether to treat the next CLI token as the flag's
+        value or as a new option. If ``prompt`` is enabled with
+        ``prompt_required=False``, it opens the door for an interactive value, hence the
+        initial condition. Ref: https://github.com/pallets/click/issues/3084
+        """
+        needs_value = self.prompt is not None and not self.prompt_required
+
+        if is_flag is None:
+            # Implicitly a flag because flag_value was set.
+            if flag_value is not UNSET:
+                return True, needs_value
+            # Not a flag, but when used as a flag it shows a prompt.
+            if needs_value:
+                return False, needs_value
+            # Implicitly a flag because secondary options names were given.
+            if self.secondary_opts:
+                return True, needs_value
+            return False, needs_value
+
+        if is_flag is False and not needs_value:
+            # Explicit ``is_flag=False`` with a flag-like value/default still makes the
+            # option flag-shaped to the parser.
+            needs_value = flag_value is not UNSET or self.default is UNSET
+
+        return bool(is_flag), needs_value
+
+    def _pick_type(
+        self,
+        type_arg: t.Any,
+        flag_value: t.Any,
+        count: bool,
+        is_flag: bool,
+    ) -> types.ParamType[t.Any]:
+        """Pick the final :class:`ParamType` for this option.
+
+        :meth:`Parameter.__init__` already stored ``self.type`` from the explicit
+        ``type`` argument or from ``default``. This method either returns that as-is, or
+        overrides it for flag and count options (which are inferred from ``flag_value``
+        rather than ``default``).
+        """
+        if type_arg is not None:
+            return self.type
+
+        if count:
+            return types.IntRange(min=0)
+
+        if not is_flag:
+            return self.type
+
+        # A flag without a flag_value is a boolean flag.
+        if flag_value is UNSET or isinstance(flag_value, bool):
+            return types.BoolParamType()
+
+        guessed: types.ParamType[t.Any] = types.convert_type(None, flag_value)
+        if (
+            isinstance(guessed, types.StringParamType)
+            and not isinstance(flag_value, str)
+            and flag_value is not None
+        ):
+            # The flag_value type couldn't be auto-detected (not str, int, float, or
+            # bool). Since flag_value is a programmer-provided Python object, not CLI
+            # input, pass it through unchanged instead of stringifying it.
+            return types.UNPROCESSED
+        return guessed
+
+    def _resolve_lazy_default(self, value: t.Any) -> t.Any:
+        """Apply lazy auto-derivations to a default-style value.
+
+        Shared between :meth:`get_default` (the runtime path) and :meth:`to_info_dict`
+        (the introspection path) so the two views cannot drift apart. Callables are
+        *not* invoked here: that is :meth:`get_default`'s responsibility. Rules:
+
+        * ``UNSET`` resolves to ``False`` for a non-required boolean flag, and to ``()``
+          for a non-required, non-prompted multi flag.
+        * ``True`` resolves to :attr:`flag_value` for a non-boolean flag (the "activate
+          this flag by default" shorthand). Boolean flags keep ``True`` as a literal.
+        """
+        if value is UNSET and self.is_flag:
+            if self.multiple and not self.required and not self.prompt:
+                return ()
+            if self.is_bool_flag and not self.required:
+                return False
+        if value is True and self.is_flag and not self.is_bool_flag:
+            # Use ``flag_activation_value`` so an unset ``flag_value`` resolves to
+            # ``True`` (the bool-flag activation value) rather than leaking the
+            # :data:`UNSET` sentinel.
+            return self.flag_activation_value
+        return value
+
+    def _validate(self, prompt: bool | str, deprecated: bool | str) -> None:
+        """Raise :class:`TypeError` / :class:`ValueError` on illegal kwarg combinations.
+
+        Called once, after every other attribute has been assigned, so each check can
+        read the final state.
+        """
+        if not __debug__:
+            return
+        if deprecated and prompt:
+            raise ValueError("`deprecated` options cannot use `prompt`.")
+        if self.nargs == -1:
+            raise TypeError("nargs=-1 is not supported for options.")
+        if not self.is_bool_flag and self.secondary_opts:
+            raise TypeError("Secondary flag is not valid for non-boolean flag.")
+        if self.is_bool_flag and self.hide_input and self.prompt is not None:
+            raise TypeError("'prompt' with 'hide_input' is not valid for boolean flag.")
+        if self.count:
+            if self.multiple:
+                raise TypeError("'count' is not valid with 'multiple'.")
+            if self.is_flag:
+                raise TypeError("'count' is not valid with 'is_flag'.")
+
+    def to_info_dict(self) -> dict[str, t.Any]:
+        """
+        .. versionchanged:: 8.5.0
+            ``default`` and ``flag_value`` reflect the auto-derived values (``False``
+            for unset boolean-flag defaults, ``True`` for unset boolean-flag activation
+            values, etc.) when no explicit value was passed, matching what the function
+            would receive at call time.
+
+        .. versionchanged:: 8.3.0
+            Returns ``None`` for the :attr:`flag_value` if it was not set.
+        """
+        info_dict = super().to_info_dict()
+        info_dict.update(
+            default=self._hide_unset(self._resolve_lazy_default(self.default)),
+            help=self.help,
+            prompt=self.prompt,
+            is_flag=self.is_flag,
+            flag_value=self.flag_activation_value,
+            count=self.count,
+            hidden=self.hidden,
+        )
+        return info_dict
+
+    def get_default(
+        self, ctx: Context, call: bool = True
+    ) -> t.Any | t.Callable[[], t.Any] | None:
+        """Return the default value for this option.
+
+        Several auto-derived defaults are resolved lazily here rather than eagerly in
+        :meth:`__init__`. This keeps :attr:`default` raw at construction time, so
+        ``self.default is UNSET`` reliably answers "did the user pass a default?" for
+        feature-switch-group arbitration and for anything else that needs to distinguish
+        "absent" from a chosen value. The resolution rules live in
+        :meth:`_resolve_lazy_default`.
+
+        .. versionchanged:: 8.5.0
+            ``UNSET`` defaults for boolean and multi flags are now resolved here instead
+            of being coerced in :meth:`__init__`. Reading :attr:`default` directly
+            returns the user-supplied value (or ``UNSET`` if none was passed) rather
+            than the auto-derived one.
+
+        .. versionchanged:: 8.3.3
+            ``default=True`` is no longer substituted with ``flag_value`` for boolean
+            flags, fixing negative boolean flags like
+            ``flag_value=False, default=True``.
+        """
+        raw = super().get_default(ctx, call=False)
+        value = self._resolve_lazy_default(raw)
+        # Only invoke the value as a callable when the lazy resolver passed it through
+        # unchanged. If the resolver substituted ``True`` -> :attr:`flag_value`, the
+        # result is the programmer-supplied ``flag_value`` (often a class or enum),
+        # which must NOT be instantiated here. See
+        # https://github.com/pallets/click/issues/3121.
+        if value is raw and call and callable(value):
+            value = value()
+        return value
+
+    def get_error_hint(self, ctx: Context | None) -> str:
+        result = super().get_error_hint(ctx)
+        if self.show_envvar and self.envvar is not None:
+            result += f" (env var: '{self.envvar}')"
+        return result
+
+    def _parse_decls(
+        self, decls: cabc.Sequence[str], expose_value: bool
+    ) -> tuple[str, list[str], list[str]]:
+        opts = []
+        secondary_opts = []
+        name = None
+        possible_names = []
+
+        for decl in decls:
+            if decl.isidentifier():
+                if name is not None:
+                    raise TypeError(_("Name '{name}' defined twice").format(name=name))
+                name = decl
+            else:
+                split_char = ";" if decl[:1] == "/" else "/"
+                if split_char in decl:
+                    first, second = decl.split(split_char, 1)
+                    first = first.rstrip()
+                    if first:
+                        possible_names.append(_split_opt(first))
+                        opts.append(first)
+                    second = second.lstrip()
+                    if second:
+                        secondary_opts.append(second.lstrip())
+                    if first == second:
+                        raise ValueError(
+                            _(
+                                "Boolean option {decl!r} cannot use the"
+                                " same flag for true/false."
+                            ).format(decl=decl)
+                        )
+                else:
+                    possible_names.append(_split_opt(decl))
+                    opts.append(decl)
+
+        if name is None and possible_names:
+            possible_names.sort(key=lambda x: -len(x[0]))  # group long options first
+            name = possible_names[0][1].replace("-", "_").lower()
+            if not name.isidentifier():
+                name = None
+
+        if name is None:
+            if not expose_value:
+                return "", opts, secondary_opts
+            raise TypeError(
+                _(
+                    "Could not determine name for option with declarations {decls!r}"
+                ).format(decls=decls)
+            )
+
+        if not opts and not secondary_opts:
+            raise TypeError(
+                _(
+                    "No options defined but a name was passed ({name})."
+                    " Did you mean to declare an argument instead? Did"
+                    " you mean to pass '--{name}'?"
+                ).format(name=name)
+            )
+
+        return name, opts, secondary_opts
+
+    def add_to_parser(self, parser: _OptionParser, ctx: Context) -> None:
+        if self.multiple:
+            action = "append"
+        elif self.count:
+            action = "count"
+        else:
+            action = "store"
+
+        if self.is_flag:
+            action = f"{action}_const"
+
+            if self.is_bool_flag and self.secondary_opts:
+                parser.add_option(
+                    obj=self, opts=self.opts, dest=self.name, action=action, const=True
+                )
+                parser.add_option(
+                    obj=self,
+                    opts=self.secondary_opts,
+                    dest=self.name,
+                    action=action,
+                    const=False,
+                )
+            else:
+                parser.add_option(
+                    obj=self,
+                    opts=self.opts,
+                    dest=self.name,
+                    action=action,
+                    # ``flag_activation_value`` resolves UNSET to the right parser-store
+                    # constant (``True`` for bool flags) so the raw :attr:`flag_value`
+                    # can keep the sentinel.
+                    const=self.flag_activation_value,
+                )
+        else:
+            parser.add_option(
+                obj=self,
+                opts=self.opts,
+                dest=self.name,
+                action=action,
+                nargs=self.nargs,
+            )
+
+    def get_help_record(self, ctx: Context) -> tuple[str, str] | None:
+        if self.hidden:
+            return None
+
+        any_prefix_is_slash = False
+
+        def _write_opts(opts: cabc.Sequence[str]) -> str:
+            nonlocal any_prefix_is_slash
+
+            rv, any_slashes = join_options(opts)
+
+            if any_slashes:
+                any_prefix_is_slash = True
+
+            if not self.is_flag and not self.count:
+                rv += f" {self.make_metavar(ctx=ctx)}"
+
+            return rv
+
+        rv = [_write_opts(self.opts)]
+
+        if self.secondary_opts:
+            rv.append(_write_opts(self.secondary_opts))
+
+        help = self.help or ""
+
+        extra = self.get_help_extra(ctx)
+        extra_items = []
+        if "envvars" in extra:
+            extra_items.append(
+                _("env var: {var}").format(var=", ".join(extra["envvars"]))
+            )
+        if "default" in extra:
+            extra_items.append(_("default: {default}").format(default=extra["default"]))
+        if "range" in extra:
+            extra_items.append(extra["range"])
+        if "required" in extra:
+            extra_items.append(_(extra["required"]))
+
+        if extra_items:
+            extra_str = "; ".join(extra_items)
+            help = f"{help}  [{extra_str}]" if help else f"[{extra_str}]"
+
+        return ("; " if any_prefix_is_slash else " / ").join(rv), help
+
+    def get_help_extra(self, ctx: Context) -> types.OptionHelpExtra:
+        extra: types.OptionHelpExtra = {}
+
+        if self.show_envvar:
+            envvar = self.envvar
+
+            if envvar is None:
+                if (
+                    self.allow_from_autoenv
+                    and ctx.auto_envvar_prefix is not None
+                    and self.name
+                ):
+                    envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
+
+            if envvar is not None:
+                if isinstance(envvar, str):
+                    extra["envvars"] = (envvar,)
+                else:
+                    extra["envvars"] = tuple(str(d) for d in envvar)
+
+        # Temporarily enable resilient parsing to avoid type casting
+        # failing for the default. Might be possible to extend this to
+        # help formatting in general.
+        resilient = ctx.resilient_parsing
+        ctx.resilient_parsing = True
+
+        try:
+            default_value = self.get_default(ctx, call=False)
+        finally:
+            ctx.resilient_parsing = resilient
+
+        show_default = False
+        show_default_is_str = False
+
+        if self.show_default is not None:
+            if isinstance(self.show_default, str):
+                show_default_is_str = show_default = True
+            else:
+                show_default = self.show_default
+        elif ctx.show_default is not None:
+            show_default = ctx.show_default
+
+        if show_default_is_str or (
+            show_default and (default_value not in (None, UNSET))
+        ):
+            if show_default_is_str:
+                default_string = f"({self.show_default})"
+            elif isinstance(default_value, (list, tuple)):
+                default_string = ", ".join(str(d) for d in default_value)
+            elif isinstance(default_value, enum.Enum):
+                default_string = default_value.name
+            elif inspect.isfunction(default_value):
+                default_string = _("(dynamic)")
+            elif self.is_bool_flag and self.secondary_opts:
+                # For boolean flags that have distinct True/False opts,
+                # use the opt without prefix instead of the value.
+                default_string = _split_opt(
+                    (self.opts if default_value else self.secondary_opts)[0]
+                )[1]
+            elif self.is_bool_flag and not self.secondary_opts and not default_value:
+                default_string = ""
+            elif isinstance(default_value, str) and default_value == "":
+                default_string = '""'
+            else:
+                default_string = str(default_value)
+
+            if default_string:
+                extra["default"] = default_string
+
+        if (
+            isinstance(self.type, types._NumberRangeBase)
+            # skip count with default range type
+            and not (self.count and self.type.min == 0 and self.type.max is None)
+        ):
+            range_str = self.type._describe_range()
+
+            if range_str:
+                extra["range"] = range_str
+
+        if self.required:
+            extra["required"] = "required"
+
+        return extra
+
+    def prompt_for_value(self, ctx: Context) -> t.Any:
+        """This is an alternative flow that can be activated in the full
+        value processing if a value does not exist.  It will prompt the
+        user until a valid value exists and then returns the processed
+        value as result.
+        """
+        assert self.prompt is not None
+
+        # Calculate the default before prompting anything to lock in the value before
+        # attempting any user interaction.
+        default = self.get_default(ctx)
+
+        # A boolean flag can use a simplified [y/n] confirmation prompt.
+        if self.is_bool_flag:
+            # If we have no boolean default, we force the user to explicitly provide
+            # one.
+            if default in (UNSET, None):
+                default = None
+            # Nothing prevent you to declare an option that is simultaneously:
+            # 1) auto-detected as a boolean flag,
+            # 2) allowed to prompt, and
+            # 3) still declare a non-boolean default.
+            # This forced casting into a boolean is necessary to align any non-boolean
+            # default to the prompt, which is going to be a [y/n]-style confirmation
+            # because the option is still a boolean flag. That way, instead of [y/n],
+            # we get [Y/n] or [y/N] depending on the truthy value of the default.
+            # Refs: https://github.com/pallets/click/pull/3030#discussion_r2289180249
+            else:
+                default = bool(default)
+            return confirm(self.prompt, default)
+
+        # If show_default is given, provide this to `prompt` as well,
+        # otherwise we use `prompt`'s default behavior
+        prompt_kwargs: t.Any = {}
+        if self.show_default is not None:
+            prompt_kwargs["show_default"] = self.show_default
+
+        return prompt(
+            self.prompt,
+            # Use ``None`` to inform the prompt() function to reiterate until a valid
+            # value is provided by the user if we have no default.
+            default=self._hide_unset(default),
+            type=self.type,
+            hide_input=self.hide_input,
+            show_choices=self.show_choices,
+            confirmation_prompt=self.confirmation_prompt,
+            value_proc=lambda x: self.process_value(ctx, x),
+            **prompt_kwargs,
+        )
+
+    def resolve_envvar_value(self, ctx: Context) -> str | None:
+        """:class:`Option` resolves its environment variable the same way as
+        :func:`Parameter.resolve_envvar_value`, but it also supports
+        :attr:`Context.auto_envvar_prefix`. If we could not find an environment from
+        the :attr:`envvar` property, we fallback on :attr:`Context.auto_envvar_prefix`
+        to build dynamiccaly the environment variable name using the
+        :python:`{ctx.auto_envvar_prefix}_{self.name.upper()}` template.
+
+        :meta private:
+        """
+        rv = super().resolve_envvar_value(ctx)
+
+        if rv is not None:
+            return rv
+
+        if self.allow_from_autoenv and ctx.auto_envvar_prefix is not None and self.name:
+            envvar = f"{ctx.auto_envvar_prefix}_{self.name.upper()}"
+            rv = os.environ.get(envvar)
+
+            if rv:
+                return rv
+
+        return None
+
+    def value_from_envvar(self, ctx: Context) -> t.Any:
+        """For :class:`Option`, this method processes the raw environment variable
+        string the same way as :func:`Parameter.value_from_envvar` does.
+
+        But in the case of non-boolean flags, the value is analyzed to determine if the
+        flag is activated or not, and returns a boolean of its activation, or the
+        :attr:`flag_value` if the latter is set.
+
+        This method also takes care of repeated options (i.e. options with
+        :attr:`multiple` set to ``True``).
+
+        :meta private:
+        """
+        rv = self.resolve_envvar_value(ctx)
+
+        # Absent environment variable or an empty string is interpreted as unset.
+        if rv is None:
+            return None
+
+        # Non-boolean flags are more liberal in what they accept. But a flag being a
+        # flag, its envvar value still needs to be analyzed to determine if the flag is
+        # activated or not.
+        if self.is_flag and not self.is_bool_flag:
+            # An exact match against ``flag_value`` (a non-bool flag always has one
+            # explicitly set) returns it directly. Otherwise the value is analyzed as a
+            # boolean: a truthy reading activates the flag and the function receives
+            # ``flag_value``; a falsy reading produces ``False``; an unrecognized
+            # reading falls through as ``None``. Folding the substitution here means
+            # :meth:`consume_value` no longer has to repeat it in a source-checked
+            # branch.
+            if rv == self.flag_value:
+                return self.flag_value
+            parsed = types.BoolParamType.str_to_bool(rv)
+            if parsed is None:
+                return None
+            return self.flag_value if parsed else False
+
+        # Split the envvar value if it is allowed to be repeated.
+        value_depth = (self.nargs != 1) + bool(self.multiple)
+        if value_depth > 0:
+            multi_rv = self.type.split_envvar_value(rv)
+            if self.multiple and self.nargs != 1:
+                multi_rv = batch(multi_rv, self.nargs)  # type: ignore[assignment]
+
+            return multi_rv
+
+        return rv
+
+    def consume_value(
+        self, ctx: Context, opts: cabc.Mapping[str, Parameter]
+    ) -> tuple[t.Any, ParameterSource]:
+        """For :class:`Option`, the value can be collected from an interactive prompt
+        if the option is a flag that needs a value (and the :attr:`prompt` property is
+        set).
+
+        Additionally, this method handles flag option that are activated without a
+        value, in which case the :attr:`flag_value` is returned.
+
+        :meta private:
+        """
+        value, source = super().consume_value(ctx, opts)
+
+        # The parser emits a sentinel when a flag is allowed to be used without a value.
+        # Resolve it to a prompt or to the activation value depending on the option's
+        # configuration.
+        if value is FLAG_NEEDS_VALUE:
+            # If the option allows for a prompt, start an interaction with the user.
+            if self.prompt is not None and not ctx.resilient_parsing:
+                value = self.prompt_for_value(ctx)
+                source = ParameterSource.PROMPT
+            # Else the flag takes its activation value (resolves UNSET).
+            else:
+                value = self.flag_activation_value
+                source = ParameterSource.COMMANDLINE
+
+        # Re-interpret a multiple option that the parser sent through as a list still
+        # containing the FLAG_NEEDS_VALUE sentinel, replacing each occurrence with the
+        # activation value.
+        elif (
+            self.multiple
+            and value is not UNSET
+            and isinstance(value, cabc.Iterable)
+            and source < ParameterSource.DEFAULT_MAP
+            and any(v is FLAG_NEEDS_VALUE for v in value)
+        ):
+            value = [
+                self.flag_activation_value if v is FLAG_NEEDS_VALUE else v
+                for v in value
+            ]
+            source = ParameterSource.COMMANDLINE
+
+        # The value wasn't set, or used the param's default, prompt for one to the user
+        # if prompting is enabled.
+        elif (
+            (value is UNSET or source >= ParameterSource.DEFAULT_MAP)
+            and self.prompt is not None
+            and (self.required or self.prompt_required)
+            and not ctx.resilient_parsing
+        ):
+            value = self.prompt_for_value(ctx)
+            source = ParameterSource.PROMPT
+
+        return value, source
+
+    def process_value(self, ctx: Context, value: t.Any) -> t.Any:
+        # process_value has to be overridden on Options in order to capture
+        # `value == UNSET` cases before `type_cast_value()` gets called.
+        #
+        # Refs:
+        # https://github.com/pallets/click/issues/3069
+        if self.is_flag and not self.required and self.is_bool_flag and value is UNSET:
+            value = False
+
+            if self.callback is not None:
+                value = self.callback(ctx, self, value)
+
+            return value
+
+        # in the normal case, rely on Parameter.process_value
+        return super().process_value(ctx, value)
+
+
+class Argument(Parameter):
+    """Arguments are positional parameters to a command.  They generally
+    provide fewer features than options but can have infinite ``nargs``
+    and are required by default.
+
+    All parameters are passed onwards to the constructor of :class:`Parameter`.
+
+    :param help: the help string.
+
+    .. versionchanged:: 8.5.0
+        Added the ``help`` parameter.
+    """
+
+    param_type_name = "argument"
+
+    def __init__(
+        self,
+        param_decls: cabc.Sequence[str],
+        required: bool | None = None,
+        help: str | None = None,
+        **attrs: t.Any,
+    ) -> None:
+        # Auto-detect the requirement status of the argument if not explicitly set.
+        if required is None:
+            # The argument gets automatically required if it has no explicit default
+            # value set and is setup to match at least one value.
+            if attrs.get("default", UNSET) is UNSET:
+                required = attrs.get("nargs", 1) > 0
+            # If the argument has a default value, it is not required.
+            else:
+                required = False
+
+        if "multiple" in attrs:
+            raise TypeError("__init__() got an unexpected keyword argument 'multiple'.")
+
+        deprecated = attrs.get("deprecated", False)
+
+        if help:
+            help = inspect.cleandoc(help)
+
+        if deprecated:
+            label = _format_deprecated_label(deprecated)
+            help = f"{help} {label}" if help else label
+
+        self.help = help
+
+        super().__init__(param_decls, required=required, **attrs)
+
+    def to_info_dict(self) -> dict[str, t.Any]:
+        info_dict = super().to_info_dict()
+        info_dict.update(help=self.help)
+        return info_dict
+
+    @property
+    def human_readable_name(self) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        return self.name.upper()
+
+    def make_metavar(self, ctx: Context) -> str:
+        if self.metavar is not None:
+            return self.metavar
+        var = self.type.get_metavar(param=self, ctx=ctx)
+        if not var:
+            var = self.name.upper()
+        # Types like ``Choice`` and ``DateTime`` already surround their metavar
+        # with square brackets to enumerate the allowed values. Reuse those
+        # outer brackets as the optional-argument indicator instead of wrapping
+        # the metavar in a second pair, which would produce ``[[a|b|c]]``.
+        already_bracketed = var.startswith("[") and var.endswith("]")
+        if self.deprecated:
+            var += "!"
+        if not self.required and not already_bracketed:
+            var = f"[{var}]"
+        if self.nargs != 1:
+            var += "..."
+        return var
+
+    def _parse_decls(
+        self, decls: cabc.Sequence[str], expose_value: bool
+    ) -> tuple[str, list[str], list[str]]:
+        if not decls:
+            if not expose_value:
+                return "", [], []
+            raise TypeError("Argument is marked as exposed, but does not have a name.")
+        if len(decls) == 1:
+            name = arg = decls[0]
+            name = name.replace("-", "_").lower()
+        else:
+            raise TypeError(
+                _(
+                    "Arguments take exactly one parameter declaration, got"
+                    " {length}: {decls}."
+                ).format(length=len(decls), decls=decls)
+            )
+        return name, [arg], []
+
+    def get_usage_pieces(self, ctx: Context) -> list[str]:
+        return [self.make_metavar(ctx)]
+
+    def get_help_record(self, ctx: Context) -> tuple[str, str] | None:
+        if self.help is None:
+            return None
+
+        return self.make_metavar(ctx), self.help
+
+    def get_error_hint(self, ctx: Context | None) -> str:
+        if ctx is not None:
+            return f"'{self.make_metavar(ctx)}'"
+        return f"'{self.human_readable_name}'"
+
+    def add_to_parser(self, parser: _OptionParser, ctx: Context) -> None:
+        parser.add_argument(dest=self.name, nargs=self.nargs, obj=self)
+
+
+def __getattr__(name: str) -> object:
+    import warnings
+
+    if name == "BaseCommand":
+        warnings.warn(
+            "'BaseCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Command' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _BaseCommand
+
+    if name == "MultiCommand":
+        warnings.warn(
+            "'MultiCommand' is deprecated and will be removed in Click 9.0. Use"
+            " 'Group' instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return _MultiCommand
+
+    raise AttributeError(name)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/decorators.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/decorators.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc42e5d42c48e7bddca9346bc4dd4f240a30c2e3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/decorators.py
@@ -0,0 +1,627 @@
+from __future__ import annotations
+
+import inspect
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .globals import get_current_context
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+T = t.TypeVar("T")
+_AnyCallable = t.Callable[..., t.Any]
+FC = t.TypeVar("FC", bound="_AnyCallable | Command")
+
+
+def pass_context(f: t.Callable[te.Concatenate[Context, P], R]) -> t.Callable[P, R]:
+    """Marks a callback as wanting to receive the current context
+    object as first argument.
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(get_current_context(), *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def pass_obj(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+    """Similar to :func:`pass_context`, but only pass the object on the
+    context onwards (:attr:`Context.obj`).  This is useful if that object
+    represents the state of a nested system.
+    """
+
+    def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+        return f(get_current_context().obj, *args, **kwargs)
+
+    return update_wrapper(new_func, f)
+
+
+def make_pass_decorator(
+    object_type: type[T], ensure: bool = False
+) -> t.Callable[[t.Callable[te.Concatenate[T, P], R]], t.Callable[P, R]]:
+    """Given an object type this creates a decorator that will work
+    similar to :func:`pass_obj` but instead of passing the object of the
+    current context, it will find the innermost context of type
+    :func:`object_type`.
+
+    This generates a decorator that works roughly like this::
+
+        from functools import update_wrapper
+
+        def decorator(f):
+            @pass_context
+            def new_func(ctx, *args, **kwargs):
+                obj = ctx.find_object(object_type)
+                return ctx.invoke(f, obj, *args, **kwargs)
+            return update_wrapper(new_func, f)
+        return decorator
+
+    :param object_type: the type of the object to pass.
+    :param ensure: if set to `True`, a new object will be created and
+                   remembered on the context if it's not there yet.
+    """
+
+    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+        def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+            ctx = get_current_context()
+
+            obj: T | None
+            if ensure:
+                obj = ctx.ensure_object(object_type)
+            else:
+                obj = ctx.find_object(object_type)
+
+            if obj is None:
+                raise RuntimeError(
+                    "Managed to invoke callback without a context"
+                    f" object of type {object_type.__name__!r}"
+                    " existing."
+                )
+
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    return decorator
+
+
+def pass_meta_key(
+    key: str, *, doc_description: str | None = None
+) -> t.Callable[[t.Callable[te.Concatenate[T, P], R]], t.Callable[P, R]]:
+    """Create a decorator that passes a key from
+    :attr:`click.Context.meta` as the first argument to the decorated
+    function.
+
+    :param key: Key in ``Context.meta`` to pass.
+    :param doc_description: Description of the object being passed,
+        inserted into the decorator's docstring. Defaults to "the 'key'
+        key from Context.meta".
+
+    .. versionadded:: 8.0
+    """
+
+    def decorator(f: t.Callable[te.Concatenate[T, P], R]) -> t.Callable[P, R]:
+        def new_func(*args: P.args, **kwargs: P.kwargs) -> R:
+            ctx = get_current_context()
+            obj = ctx.meta[key]
+            return ctx.invoke(f, obj, *args, **kwargs)
+
+        return update_wrapper(new_func, f)
+
+    if doc_description is None:
+        doc_description = f"the {key!r} key from :attr:`click.Context.meta`"
+
+    decorator.__doc__ = (
+        f"Decorator that passes {doc_description} as the first argument"
+        " to the decorated function."
+    )
+    return decorator
+
+
+CmdType = t.TypeVar("CmdType", bound=Command)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def command(name: _AnyCallable) -> Command: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @command(namearg, CommandCls, ...) or @command(namearg, cls=CommandCls, ...)
+@t.overload
+def command(
+    name: str | None,
+    cls: type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @command(cls=CommandCls, ...)
+@t.overload
+def command(
+    name: None = None,
+    *,
+    cls: type[CmdType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], CmdType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def command(
+    name: str | None = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Command]: ...
+
+
+def command(
+    name: str | _AnyCallable | None = None,
+    cls: type[CmdType] | None = None,
+    **attrs: t.Any,
+) -> Command | t.Callable[[_AnyCallable], Command | CmdType]:
+    r"""Creates a new :class:`Command` and uses the decorated function as
+    callback.  This will also automatically attach all decorated
+    :func:`option`\s and :func:`argument`\s as parameters to the command.
+
+    The name of the command defaults to the name of the function, converted to
+    lowercase, with underscores ``_`` replaced by dashes ``-``, and the suffixes
+    ``_command``, ``_cmd``, ``_group``, and ``_grp`` are removed. For example,
+    ``init_data_command`` becomes ``init-data``.
+
+    All keyword arguments are forwarded to the underlying command class.
+    For the ``params`` argument, any decorated params are appended to
+    the end of the list.
+
+    Once decorated the function turns into a :class:`Command` instance
+    that can be invoked as a command line utility or be attached to a
+    command :class:`Group`.
+
+    :param name: The name of the command. Defaults to modifying the function's
+        name as described above.
+    :param cls: The command class to create. Defaults to :class:`Command`.
+
+    .. versionchanged:: 8.2
+        The suffixes ``_command``, ``_cmd``, ``_group``, and ``_grp`` are
+        removed when generating the name.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+
+    .. versionchanged:: 8.1
+        The ``params`` argument can be used. Decorated params are
+        appended to the end of the list.
+    """
+
+    func: t.Callable[[_AnyCallable], t.Any] | None = None
+
+    if callable(name):
+        func = name
+        name = None
+        assert cls is None, "Use 'command(cls=cls)(callable)' to specify a class."
+        assert not attrs, "Use 'command(**kwargs)(callable)' to provide arguments."
+
+    if cls is None:
+        cls = t.cast("type[CmdType]", Command)
+
+    def decorator(f: _AnyCallable) -> CmdType:
+        if isinstance(f, Command):
+            raise TypeError("Attempted to convert a callback into a command twice.")
+
+        attr_params = attrs.pop("params", None)
+        params = attr_params if attr_params is not None else []
+
+        try:
+            decorator_params = f.__click_params__  # type: ignore
+        except AttributeError:
+            pass
+        else:
+            del f.__click_params__  # type: ignore
+            params.extend(reversed(decorator_params))
+
+        if attrs.get("help") is None:
+            attrs["help"] = f.__doc__
+
+        if t.TYPE_CHECKING:
+            assert cls is not None
+            assert not callable(name)
+
+        if name is not None:
+            cmd_name = name
+        else:
+            cmd_name = f.__name__.lower().replace("_", "-")
+            cmd_left, sep, suffix = cmd_name.rpartition("-")
+
+            if sep and suffix in {"command", "cmd", "group", "grp"}:
+                cmd_name = cmd_left
+
+        cmd = cls(name=cmd_name, callback=f, params=params, **attrs)
+        cmd.__doc__ = f.__doc__
+        return cmd
+
+    if func is not None:
+        return decorator(func)
+
+    return decorator
+
+
+GrpType = t.TypeVar("GrpType", bound=Group)
+
+
+# variant: no call, directly as decorator for a function.
+@t.overload
+def group(name: _AnyCallable) -> Group: ...
+
+
+# variant: with positional name and with positional or keyword cls argument:
+# @group(namearg, GroupCls, ...) or @group(namearg, cls=GroupCls, ...)
+@t.overload
+def group(
+    name: str | None,
+    cls: type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: name omitted, cls _must_ be a keyword argument, @group(cmd=GroupCls, ...)
+@t.overload
+def group(
+    name: None = None,
+    *,
+    cls: type[GrpType],
+    **attrs: t.Any,
+) -> t.Callable[[_AnyCallable], GrpType]: ...
+
+
+# variant: with optional string name, no cls argument provided.
+@t.overload
+def group(
+    name: str | None = ..., cls: None = None, **attrs: t.Any
+) -> t.Callable[[_AnyCallable], Group]: ...
+
+
+def group(
+    name: str | _AnyCallable | None = None,
+    cls: type[GrpType] | None = None,
+    **attrs: t.Any,
+) -> Group | t.Callable[[_AnyCallable], Group | GrpType]:
+    """Creates a new :class:`Group` with a function as callback.  This
+    works otherwise the same as :func:`command` just that the `cls`
+    parameter is set to :class:`Group`.
+
+    .. versionchanged:: 8.1
+        This decorator can be applied without parentheses.
+    """
+    if cls is None:
+        cls = t.cast("type[GrpType]", Group)
+
+    if callable(name):
+        return command(cls=cls, **attrs)(name)
+
+    return command(name, cls, **attrs)
+
+
+def _param_memo(f: t.Callable[..., t.Any], param: Parameter) -> None:
+    if isinstance(f, Command):
+        f.params.append(param)
+    else:
+        if not hasattr(f, "__click_params__"):
+            f.__click_params__ = []  # type: ignore
+
+        f.__click_params__.append(param)  # type: ignore
+
+
+def argument(
+    *param_decls: str, cls: type[Argument] | None = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an argument to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Argument`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Argument` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default argument class, refer to :class:`Argument` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the argument class to instantiate.  This defaults to
+                :class:`Argument`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Argument
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def option(
+    *param_decls: str, cls: type[Option] | None = None, **attrs: t.Any
+) -> t.Callable[[FC], FC]:
+    """Attaches an option to the command.  All positional arguments are
+    passed as parameter declarations to :class:`Option`; all keyword
+    arguments are forwarded unchanged (except ``cls``).
+    This is equivalent to creating an :class:`Option` instance manually
+    and attaching it to the :attr:`Command.params` list.
+
+    For the default option class, refer to :class:`Option` and
+    :class:`Parameter` for descriptions of parameters.
+
+    :param cls: the option class to instantiate.  This defaults to
+                :class:`Option`.
+    :param param_decls: Passed as positional arguments to the constructor of
+        ``cls``.
+    :param attrs: Passed as keyword arguments to the constructor of ``cls``.
+    """
+    if cls is None:
+        cls = Option
+
+    def decorator(f: FC) -> FC:
+        _param_memo(f, cls(param_decls, **attrs))
+        return f
+
+    return decorator
+
+
+def confirmation_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--yes`` option which shows a prompt before continuing if
+    not passed. If the prompt is declined, the program will exit.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--yes"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value:
+            ctx.abort()
+
+    if not param_decls:
+        param_decls = ("--yes",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("callback", callback)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("prompt", _("Do you want to continue?"))
+    kwargs.setdefault("help", _("Confirm the action without prompting."))
+    return option(*param_decls, **kwargs)
+
+
+def password_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Add a ``--password`` option which prompts for a password, hiding
+    input and asking to enter the value again for confirmation.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--password"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+    if not param_decls:
+        param_decls = ("--password",)
+
+    kwargs.setdefault("prompt", True)
+    kwargs.setdefault("confirmation_prompt", True)
+    kwargs.setdefault("hide_input", True)
+    return option(*param_decls, **kwargs)
+
+
+def version_option(
+    version: str | None = None,
+    *param_decls: str,
+    package_name: str | None = None,
+    prog_name: str | None = None,
+    message: str | None = None,
+    **kwargs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """Add a ``--version`` option which immediately prints the version
+    number and exits the program.
+
+    If ``version`` is not provided, Click will try to detect it using
+    :func:`importlib.metadata.version` to get the version for the
+    ``package_name``.
+
+    If ``package_name`` is not provided, Click will try to detect it by
+    inspecting the stack frames. If the detected (or given) name does
+    not match an installed distribution, Click resolves it as an import
+    (top-level module) name via
+    :func:`importlib.metadata.packages_distributions`, so e.g. ``PIL``
+    resolves to the ``Pillow`` distribution.
+
+    .. note::
+        The parameters and message variables accepted by this option are
+        frozen: no new slots will be added, to keep the common case simple
+        and predictable. If you need values it does not expose, such as a
+        file path, the Python version, or git metadata, use
+        :func:`custom_version_option` to render the output yourself.
+
+        Rationale: `discussion #3527
+        <https://github.com/pallets/click/discussions/3527>`_.
+
+    :param version: The version number to show. If not provided, Click
+        will try to detect it.
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--version"``.
+    :param package_name: The package name to detect the version from. If
+        not provided, Click will try to detect it.
+    :param prog_name: The name of the CLI to show in the message. If not
+        provided, it will be detected from the command.
+    :param message: The message to show. The values ``%(prog)s``,
+        ``%(package)s``, and ``%(version)s`` are available. Defaults to
+        ``"%(prog)s, version %(version)s"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    :raise RuntimeError: ``version`` could not be detected.
+
+    .. versionchanged:: 8.0
+        Add the ``package_name`` parameter, and the ``%(package)s``
+        value for messages.
+
+    .. versionchanged:: 8.0
+        Use :mod:`importlib.metadata` instead of ``pkg_resources``. The
+        version is detected based on the package name, not the entry
+        point name. The Python package name must match the installed
+        package name, or be passed with ``package_name=``.
+
+    .. versionchanged:: 8.4.2
+        When ``package_name`` does not match an installed distribution,
+        Click now resolves it as an import (top-level module).
+    """
+    if message is None:
+        message = _("%(prog)s, version %(version)s")
+
+    if version is None and package_name is None:
+        frame = inspect.currentframe()
+        f_back = frame.f_back if frame is not None else None
+        f_globals = f_back.f_globals if f_back is not None else None
+        # break reference cycle
+        # https://docs.python.org/3/library/inspect.html#the-interpreter-stack
+        del frame
+
+        if f_globals is not None:
+            package_name = f_globals.get("__name__")
+
+            if package_name == "__main__":
+                package_name = f_globals.get("__package__")
+
+            if package_name:
+                package_name = package_name.partition(".")[0]
+
+    def callback(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        nonlocal prog_name
+        nonlocal version
+        nonlocal package_name
+
+        if prog_name is None:
+            prog_name = ctx.find_root().info_name
+
+        if version is None and package_name is not None:
+            import importlib.metadata
+
+            try:
+                version = importlib.metadata.version(package_name)
+            except importlib.metadata.PackageNotFoundError:
+                # The given name didn't match an installed distribution.
+                # Try resolving it as an import (top-level module) name,
+                # e.g. ``PIL`` is provided by the ``Pillow`` distribution.
+                distributions = importlib.metadata.packages_distributions().get(
+                    package_name, []
+                )
+                if len(distributions) == 1:
+                    package_name = distributions[0]
+                    version = importlib.metadata.version(package_name)
+                elif len(distributions) > 1:
+                    raise RuntimeError(
+                        f"{package_name!r} maps to multiple installed"
+                        f" distributions ({', '.join(distributions)})."
+                        " Pass 'package_name' to disambiguate."
+                    ) from None
+                else:
+                    raise RuntimeError(
+                        f"{package_name!r} is not installed. Try passing"
+                        " 'package_name' instead."
+                    ) from None
+
+        if version is None:
+            raise RuntimeError(
+                f"Could not determine the version for {package_name!r} automatically."
+            )
+
+        echo(
+            message % {"prog": prog_name, "package": package_name, "version": version},
+            color=ctx.color,
+        )
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--version",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show the version and exit."))
+    kwargs["callback"] = callback
+    return option(*param_decls, **kwargs)
+
+
+def custom_version_option(
+    callback: t.Callable[[Context], str],
+    *param_decls: str,
+    **kwargs: t.Any,
+) -> t.Callable[[FC], FC]:
+    """Add a ``--version`` option whose output is produced by ``callback``.
+
+    This is the customizable companion to :func:`version_option`. Where
+    :func:`version_option` is intentionally limited to a fixed message and
+    a small set of values, this option calls ``callback`` to build the
+    whole string to print. Use it when you need values that
+    :func:`version_option` does not expose, such as a file path, the
+    Python version, or git metadata.
+
+    :param callback: Called with the current :class:`Context` when the
+        option is invoked. Its return value is printed, then the program
+        exits.
+    :param param_decls: One or more option names. Defaults to the single
+        value ``--version``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+
+    .. versionadded:: 8.5.0
+    """
+
+    def show_version(ctx: Context, param: Parameter, value: bool) -> None:
+        if not value or ctx.resilient_parsing:
+            return
+
+        echo(callback(ctx), color=ctx.color)
+        ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--version",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show the version and exit."))
+    kwargs["callback"] = show_version
+    return option(*param_decls, **kwargs)
+
+
+def help_option(*param_decls: str, **kwargs: t.Any) -> t.Callable[[FC], FC]:
+    """Pre-configured ``--help`` option which immediately prints the help page
+    and exits the program.
+
+    :param param_decls: One or more option names. Defaults to the single
+        value ``"--help"``.
+    :param kwargs: Extra arguments are passed to :func:`option`.
+    """
+
+    def show_help(ctx: Context, param: Parameter, value: bool) -> None:
+        """Callback that print the help page on ``<stdout>`` and exits."""
+        if value and not ctx.resilient_parsing:
+            echo(ctx.get_help(), color=ctx.color)
+            ctx.exit()
+
+    if not param_decls:
+        param_decls = ("--help",)
+
+    kwargs.setdefault("is_flag", True)
+    kwargs.setdefault("expose_value", False)
+    kwargs.setdefault("is_eager", True)
+    kwargs.setdefault("help", _("Show this message and exit."))
+    kwargs.setdefault("callback", show_help)
+
+    return option(*param_decls, **kwargs)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..6272c38a448d57241d9a6bff4191897f4a9bb7d6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/exceptions.py
@@ -0,0 +1,378 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import typing as t
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import get_text_stderr
+from .globals import resolve_color_default
+from .utils import echo
+from .utils import format_filename
+
+if t.TYPE_CHECKING:
+    from .core import Command
+    from .core import Context
+    from .core import Parameter
+
+
+def _join_param_hints(param_hint: cabc.Sequence[str] | str | None) -> str | None:
+    if param_hint is not None and not isinstance(param_hint, str):
+        return " / ".join(repr(x) for x in param_hint)
+
+    return param_hint
+
+
+def _format_possibilities(possibilities: list[str]) -> str:
+    possibility_str = ", ".join(repr(p) for p in sorted(possibilities))
+    return ngettext(
+        "Did you mean {possibility}?",
+        "(Did you mean one of: {possibilities}?)",
+        len(possibilities),
+    ).format(possibility=possibility_str, possibilities=possibility_str)
+
+
+class ClickException(Exception):
+    """An exception that Click can handle and show to the user."""
+
+    #: The exit code for this exception.
+    exit_code: t.ClassVar[int] = 1
+
+    show_color: t.Final[bool | None]
+    message: t.Final[str]
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        # The context will be removed by the time we print the message, so cache
+        # the color settings here to be used later on (in `show`)
+        self.show_color = resolve_color_default()
+        self.message = message
+
+    def format_message(self) -> str:
+        return self.message
+
+    def __str__(self) -> str:
+        return self.message
+
+    def show(self, file: t.IO[t.Any] | None = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+
+        echo(
+            _("Error: {message}").format(message=self.format_message()),
+            file=file,
+            color=self.show_color,
+        )
+
+
+class UsageError(ClickException):
+    """An internal exception that signals a usage error.  This typically
+    aborts any further handling.
+
+    :param message: the error message to display.
+    :param ctx: optionally the context that caused this error.  Click will
+                fill in the context automatically in some situations.
+    """
+
+    exit_code: t.ClassVar[int] = 2
+
+    ctx: Context | None
+    cmd: t.Final[Command | None]
+
+    def __init__(self, message: str, ctx: Context | None = None) -> None:
+        super().__init__(message)
+        self.ctx = ctx
+        self.cmd = self.ctx.command if self.ctx else None
+
+    def show(self, file: t.IO[t.Any] | None = None) -> None:
+        if file is None:
+            file = get_text_stderr()
+        color = None
+        hint = ""
+        if (
+            self.ctx is not None
+            and self.ctx.command.get_help_option(self.ctx) is not None
+        ):
+            help_names = self.ctx.command.get_help_option_names(self.ctx)
+            # Pick the longest name (like ``--help`` over ``-h``) for
+            # readability in error messages.
+            hint = _("Try '{command} {option}' for help.").format(
+                command=self.ctx.command_path,
+                option=max(help_names, key=len),
+            )
+            hint = f"{hint}\n"
+        if self.ctx is not None:
+            color = self.ctx.color
+            echo(f"{self.ctx.get_usage()}\n{hint}", file=file, color=color)
+        echo(
+            _("Error: {message}").format(message=self.format_message()),
+            file=file,
+            color=color,
+        )
+
+
+class BadParameter(UsageError):
+    """An exception that formats out a standardized error message for a
+    bad parameter.  This is useful when thrown from a callback or type as
+    Click will attach contextual information to it (for instance, which
+    parameter it is).
+
+    .. versionadded:: 2.0
+
+    :param param: the parameter object that caused this error.  This can
+                  be left out, and Click will attach this info itself
+                  if possible.
+    :param param_hint: a string that shows up as parameter name.  This
+                       can be used as alternative to `param` in cases
+                       where custom validation should happen.  If it is
+                       a string it's used as such, if it's a list then
+                       each item is quoted and separated.
+    """
+
+    param: Parameter | None
+    param_hint: cabc.Sequence[str] | str | None
+
+    def __init__(
+        self,
+        message: str,
+        ctx: Context | None = None,
+        param: Parameter | None = None,
+        param_hint: cabc.Sequence[str] | str | None = None,
+    ) -> None:
+        super().__init__(message, ctx)
+        self.param = param
+        self.param_hint = param_hint
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)
+        else:
+            return _("Invalid value: {message}").format(message=self.message)
+
+        return _("Invalid value for {param_hint}: {message}").format(
+            param_hint=_join_param_hints(param_hint), message=self.message
+        )
+
+
+class MissingParameter(BadParameter):
+    """Raised if click required an option or argument but it was not
+    provided when invoking the script.
+
+    .. versionadded:: 4.0
+
+    :param param_type: a string that indicates the type of the parameter.
+                       The default is to inherit the parameter type from
+                       the given `param`.  Valid values are ``'parameter'``,
+                       ``'option'`` or ``'argument'``.
+    """
+
+    param_type: t.Final[str | None]
+
+    def __init__(
+        self,
+        message: str | None = None,
+        ctx: Context | None = None,
+        param: Parameter | None = None,
+        param_hint: cabc.Sequence[str] | str | None = None,
+        param_type: str | None = None,
+    ) -> None:
+        super().__init__(message or "", ctx, param, param_hint)
+        self.param_type = param_type
+
+    def format_message(self) -> str:
+        if self.param_hint is not None:
+            param_hint: cabc.Sequence[str] | str | None = self.param_hint
+        elif self.param is not None:
+            param_hint = self.param.get_error_hint(self.ctx)
+        else:
+            param_hint = None
+
+        param_hint = _join_param_hints(param_hint)
+        param_hint = f" {param_hint}" if param_hint else ""
+
+        param_type = self.param_type
+        if param_type is None and self.param is not None:
+            param_type = self.param.param_type_name
+
+        msg = self.message
+        if self.param is not None:
+            msg_extra = self.param.type.get_missing_message(
+                param=self.param, ctx=self.ctx
+            )
+            if msg_extra:
+                if msg:
+                    msg += f". {msg_extra}"
+                else:
+                    msg = msg_extra
+
+        msg = f" {msg}" if msg else ""
+
+        # Translate param_type for known types.
+        if param_type == "argument":
+            missing = _("Missing argument")
+        elif param_type == "option":
+            missing = _("Missing option")
+        elif param_type == "parameter":
+            missing = _("Missing parameter")
+        else:
+            missing = _("Missing {param_type}").format(param_type=param_type)
+
+        return f"{missing}{param_hint}.{msg}"
+
+    def __str__(self) -> str:
+        if not self.message:
+            param_name = self.param.name if self.param else None
+            return _("Missing parameter: {param_name}").format(param_name=param_name)
+        else:
+            return self.message
+
+
+class NoSuchOption(UsageError):
+    """Raised if Click attempted to handle an option that does not exist.
+
+    .. versionadded:: 4.0
+    """
+
+    option_name: t.Final[str]
+    possibilities: t.Final[list[str] | None]
+
+    def __init__(
+        self,
+        option_name: str,
+        message: str | None = None,
+        possibilities: cabc.Iterable[str] | None = None,
+        ctx: Context | None = None,
+    ) -> None:
+        if message is None:
+            message = _("No such option {name!r}.").format(name=option_name)
+
+        super().__init__(message, ctx)
+        self.option_name = option_name
+
+        if possibilities:
+            from difflib import get_close_matches
+
+            possibilities_ = get_close_matches(option_name, possibilities)
+        else:
+            possibilities_ = None
+        self.possibilities = possibilities_
+
+    def format_message(self) -> str:
+        if not self.possibilities:
+            return self.message
+        return f"{self.message} {_format_possibilities(self.possibilities)}"
+
+
+class NoSuchCommand(UsageError):
+    """Raised if Click attempted to handle a command that does not exist.
+
+    .. versionadded:: 8.4.0
+    """
+
+    command_name: t.Final[str]
+    possibilities: t.Final[list[str] | None]
+
+    def __init__(
+        self,
+        command_name: str,
+        message: str | None = None,
+        possibilities: cabc.Iterable[str] | None = None,
+        ctx: Context | None = None,
+    ) -> None:
+        if message is None:
+            message = _("No such command {name!r}.").format(name=command_name)
+
+        super().__init__(message, ctx)
+        self.command_name = command_name
+
+        if possibilities:
+            from difflib import get_close_matches
+
+            possibilities_ = get_close_matches(command_name, possibilities)
+        else:
+            possibilities_ = None
+        self.possibilities = possibilities_
+
+    def format_message(self) -> str:
+        if not self.possibilities:
+            return self.message
+        return f"{self.message} {_format_possibilities(self.possibilities)}"
+
+
+class BadOptionUsage(UsageError):
+    """Raised if an option is generally supplied but the use of the option
+    was incorrect.  This is for instance raised if the number of arguments
+    for an option is not correct.
+
+    .. versionadded:: 4.0
+
+    :param option_name: the name of the option being used incorrectly.
+    """
+
+    option_name: t.Final[str]
+
+    def __init__(
+        self, option_name: str, message: str, ctx: Context | None = None
+    ) -> None:
+        super().__init__(message, ctx)
+        self.option_name = option_name
+
+
+class BadArgumentUsage(UsageError):
+    """Raised if an argument is generally supplied but the use of the argument
+    was incorrect.  This is for instance raised if the number of values
+    for an argument is not correct.
+
+    .. versionadded:: 6.0
+    """
+
+
+class NoArgsIsHelpError(UsageError):
+    ctx: Context
+
+    def __init__(self, ctx: Context) -> None:
+        super().__init__(ctx.get_help(), ctx=ctx)
+
+    def show(self, file: t.IO[t.Any] | None = None) -> None:
+        echo(self.format_message(), file=file, err=True, color=self.ctx.color)
+
+
+class FileError(ClickException):
+    """Raised if a file cannot be opened."""
+
+    ui_filename: t.Final[str]
+    filename: t.Final[str]
+
+    def __init__(self, filename: str, hint: str | None = None) -> None:
+        if hint is None:
+            hint = _("unknown error")
+
+        super().__init__(hint)
+        self.ui_filename = format_filename(filename)
+        self.filename = filename
+
+    def format_message(self) -> str:
+        return _("Could not open file {filename!r}: {message}").format(
+            filename=self.ui_filename, message=self.message
+        )
+
+
+class Abort(RuntimeError):
+    """An internal signalling exception that signals Click to abort."""
+
+
+class Exit(RuntimeError):
+    """An exception that indicates that the application should exit with some
+    status code.
+
+    :param code: the status code to exit with.
+    """
+
+    __slots__ = ("exit_code",)
+
+    exit_code: t.Final[int]
+
+    def __init__(self, code: int = 0) -> None:
+        self.exit_code = code
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/formatting.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/formatting.py
new file mode 100644
index 0000000000000000000000000000000000000000..c4aa2de571a1eb17bfeb1853e315d28bc968e74c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/formatting.py
@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+from contextlib import contextmanager
+from gettext import gettext as _
+
+from ._compat import term_len
+from .parser import _split_opt
+
+# Can force a width.  This is used by the test system
+FORCED_WIDTH: int | None = None
+
+
+def measure_table(rows: cabc.Iterable[tuple[str, str]]) -> tuple[int, ...]:
+    widths: dict[int, int] = {}
+
+    for row in rows:
+        for idx, col in enumerate(row):
+            widths[idx] = max(widths.get(idx, 0), term_len(col))
+
+    return tuple(y for x, y in sorted(widths.items()))
+
+
+def iter_rows(
+    rows: cabc.Iterable[tuple[str, str]], col_count: int
+) -> cabc.Iterator[tuple[str, ...]]:
+    for row in rows:
+        yield row + ("",) * (col_count - len(row))
+
+
+def wrap_text(
+    text: str,
+    width: int = 78,
+    initial_indent: str = "",
+    subsequent_indent: str = "",
+    preserve_paragraphs: bool = False,
+) -> str:
+    """A helper function that intelligently wraps text.  By default, it
+    assumes that it operates on a single paragraph of text but if the
+    `preserve_paragraphs` parameter is provided it will intelligently
+    handle paragraphs (defined by two empty lines).
+
+    If paragraphs are handled, a paragraph can be prefixed with an empty
+    line containing the ``\\b`` character (``\\x08``) to indicate that
+    no rewrapping should happen in that block.
+
+    :param text: the text that should be rewrapped.
+    :param width: the maximum width for the text.
+    :param initial_indent: the initial indent that should be placed on the
+                           first line as a string.
+    :param subsequent_indent: the indent string that should be placed on
+                              each consecutive line.
+    :param preserve_paragraphs: if this flag is set then the wrapping will
+                                intelligently handle paragraphs.
+
+    .. versionchanged:: 8.4.0
+        Width is measured in visible characters. ANSI escape sequences in
+        ``text``, ``initial_indent``, or ``subsequent_indent`` no longer
+        count toward the width budget, so styled input wraps based on what
+        the user sees instead of raw byte length.
+    """
+    from ._textwrap import TextWrapper
+
+    text = text.expandtabs()
+    wrapper = TextWrapper(
+        width,
+        initial_indent=initial_indent,
+        subsequent_indent=subsequent_indent,
+        replace_whitespace=False,
+    )
+    if not preserve_paragraphs:
+        return wrapper.fill(text)
+
+    p: list[tuple[int, bool, str]] = []
+    buf: list[str] = []
+    indent = None
+
+    def _flush_par() -> None:
+        if not buf:
+            return
+        if buf[0].strip() == "\b":
+            p.append((indent or 0, True, "\n".join(buf[1:])))
+        else:
+            p.append((indent or 0, False, " ".join(buf)))
+        del buf[:]
+
+    for line in text.splitlines():
+        if not line:
+            _flush_par()
+            indent = None
+        else:
+            if indent is None:
+                orig_len = term_len(line)
+                line = line.lstrip()
+                indent = orig_len - term_len(line)
+            buf.append(line)
+    _flush_par()
+
+    rv = []
+    for indent, raw, text in p:
+        with wrapper.extra_indent(" " * indent):
+            if raw:
+                rv.append(wrapper.indent_only(text))
+            else:
+                rv.append(wrapper.fill(text))
+
+    return "\n\n".join(rv)
+
+
+class HelpFormatter:
+    """This class helps with formatting text-based help pages.  It's
+    usually just needed for very special internal cases, but it's also
+    exposed so that developers can write their own fancy outputs.
+
+    At present, it always writes into memory.
+
+    :param indent_increment: the additional increment for each level.
+    :param width: the width for the text.  This defaults to the terminal
+                  width clamped to a maximum of 78.
+    """
+
+    indent_increment: int
+    width: int
+    current_indent: int
+    buffer: list[str]
+
+    def __init__(
+        self,
+        indent_increment: int = 2,
+        width: int | None = None,
+        max_width: int | None = None,
+    ) -> None:
+        self.indent_increment = indent_increment
+        if max_width is None:
+            max_width = 80
+        if width is None:
+            import shutil
+
+            width = FORCED_WIDTH
+            if width is None:
+                width = max(min(shutil.get_terminal_size().columns, max_width) - 2, 50)
+        self.width = width
+        self.current_indent = 0
+        self.buffer = []
+
+    def write(self, string: str) -> None:
+        """Writes a unicode string into the internal buffer."""
+        self.buffer.append(string)
+
+    def indent(self) -> None:
+        """Increases the indentation."""
+        self.current_indent += self.indent_increment
+
+    def dedent(self) -> None:
+        """Decreases the indentation."""
+        self.current_indent -= self.indent_increment
+
+    def write_usage(self, prog: str, args: str = "", prefix: str | None = None) -> None:
+        """Writes a usage line into the buffer.
+
+        :param prog: the program name.
+        :param args: whitespace separated list of arguments.
+        :param prefix: The prefix for the first line. Defaults to
+            ``"Usage: "``.
+        """
+        if prefix is None:
+            prefix = "{usage} ".format(usage=_("Usage:"))
+
+        usage_prefix = f"{prefix:>{self.current_indent}}{prog} "
+        text_width = self.width - self.current_indent
+
+        if not args:
+            # Without args, the prefix's trailing space and the wrap_text
+            # call that would normally place args on the line are both
+            # unnecessary. Emit just the prefix line.
+            self.write(usage_prefix.rstrip(" "))
+            self.write("\n")
+            return
+
+        if text_width >= (term_len(usage_prefix) + 20):
+            # The arguments will fit to the right of the prefix.
+            indent = " " * term_len(usage_prefix)
+            self.write(
+                wrap_text(
+                    args,
+                    text_width,
+                    initial_indent=usage_prefix,
+                    subsequent_indent=indent,
+                )
+            )
+        else:
+            # The prefix is too long, put the arguments on the next line.
+            self.write(usage_prefix)
+            self.write("\n")
+            indent = " " * (max(self.current_indent, term_len(prefix)) + 4)
+            self.write(
+                wrap_text(
+                    args, text_width, initial_indent=indent, subsequent_indent=indent
+                )
+            )
+
+        self.write("\n")
+
+    def write_heading(self, heading: str) -> None:
+        """Writes a heading into the buffer."""
+        self.write(f"{'':>{self.current_indent}}{heading}:\n")
+
+    def write_paragraph(self) -> None:
+        """Writes a paragraph into the buffer."""
+        if self.buffer:
+            self.write("\n")
+
+    def write_text(self, text: str) -> None:
+        """Writes re-indented text into the buffer.  This rewraps and
+        preserves paragraphs.
+        """
+        indent = " " * self.current_indent
+        self.write(
+            wrap_text(
+                text,
+                self.width,
+                initial_indent=indent,
+                subsequent_indent=indent,
+                preserve_paragraphs=True,
+            )
+        )
+        self.write("\n")
+
+    def write_dl(
+        self,
+        rows: cabc.Iterable[tuple[str, str]],
+        col_max: int = 30,
+        col_spacing: int = 2,
+    ) -> None:
+        """Writes a definition list into the buffer.  This is how options
+        and commands are usually formatted.
+
+        :param rows: a list of two item tuples for the terms and values.
+        :param col_max: the maximum width of the first column.
+        :param col_spacing: the number of spaces between the first and
+                            second column.
+        """
+        rows = list(rows)
+        widths = measure_table(rows)
+        if len(widths) != 2:
+            raise TypeError("Expected two columns for definition list")
+
+        first_col = min(widths[0], col_max) + col_spacing
+
+        for first, second in iter_rows(rows, len(widths)):
+            self.write(f"{'':>{self.current_indent}}{first}")
+            if not second:
+                self.write("\n")
+                continue
+            if term_len(first) <= first_col - col_spacing:
+                self.write(" " * (first_col - term_len(first)))
+            else:
+                self.write("\n")
+                self.write(" " * (first_col + self.current_indent))
+
+            text_width = max(self.width - first_col - 2, 10)
+            wrapped_text = wrap_text(second, text_width, preserve_paragraphs=True)
+            lines = wrapped_text.splitlines()
+
+            if lines:
+                self.write(f"{lines[0]}\n")
+
+                for line in lines[1:]:
+                    self.write(f"{'':>{first_col + self.current_indent}}{line}\n")
+            else:
+                self.write("\n")
+
+    @contextmanager
+    def section(self, name: str) -> cabc.Generator[None]:
+        """Helpful context manager that writes a paragraph, a heading,
+        and the indents.
+
+        :param name: the section name that is written as heading.
+        """
+        self.write_paragraph()
+        self.write_heading(name)
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    @contextmanager
+    def indentation(self) -> cabc.Generator[None]:
+        """A context manager that increases the indentation."""
+        self.indent()
+        try:
+            yield
+        finally:
+            self.dedent()
+
+    def getvalue(self) -> str:
+        """Returns the buffer contents."""
+        return "".join(self.buffer)
+
+
+def join_options(options: cabc.Iterable[str]) -> tuple[str, bool]:
+    """Given a list of option strings this joins them in the most appropriate
+    way and returns them in the form ``(formatted_string,
+    any_prefix_is_slash)`` where the second item in the tuple is a flag that
+    indicates if any of the option prefixes was a slash.
+    """
+    rv = []
+    any_prefix_is_slash = False
+
+    for opt in options:
+        prefix = _split_opt(opt)[0]
+
+        if prefix == "/":
+            any_prefix_is_slash = True
+
+        rv.append((len(prefix), opt))
+
+    rv.sort(key=lambda x: x[0])
+    return ", ".join(x[1] for x in rv), any_prefix_is_slash
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/globals.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/globals.py
new file mode 100644
index 0000000000000000000000000000000000000000..a2f91723d21cefdf658be327174e1f8ccdc20fcd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/globals.py
@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+import typing as t
+from threading import local
+
+if t.TYPE_CHECKING:
+    from .core import Context
+
+_local = local()
+
+
+@t.overload
+def get_current_context(silent: t.Literal[False] = False) -> Context: ...
+
+
+@t.overload
+def get_current_context(silent: bool = ...) -> Context | None: ...
+
+
+def get_current_context(silent: bool = False) -> Context | None:
+    """Returns the current click context.  This can be used as a way to
+    access the current context object from anywhere.  This is a more implicit
+    alternative to the :func:`pass_context` decorator.  This function is
+    primarily useful for helpers such as :func:`echo` which might be
+    interested in changing its behavior based on the current context.
+
+    To push the current context, :meth:`Context.scope` can be used.
+
+    .. versionadded:: 5.0
+
+    :param silent: if set to `True` the return value is `None` if no context
+                   is available.  The default behavior is to raise a
+                   :exc:`RuntimeError`.
+    """
+    try:
+        return t.cast("Context", _local.stack[-1])
+    except (AttributeError, IndexError) as e:
+        if not silent:
+            raise RuntimeError("There is no active click context.") from e
+
+    return None
+
+
+def push_context(ctx: Context) -> None:
+    """Pushes a new context to the current stack."""
+    _local.__dict__.setdefault("stack", []).append(ctx)
+
+
+def pop_context() -> None:
+    """Removes the top level from the stack."""
+    _local.stack.pop()
+
+
+def resolve_color_default(color: bool | None = None) -> bool | None:
+    """Internal helper to get the default value of the color flag.  If a
+    value is passed it's returned unchanged, otherwise it's looked up from
+    the current context.
+    """
+    if color is not None:
+        return color
+
+    ctx = get_current_context(silent=True)
+
+    if ctx is not None:
+        return ctx.color
+
+    return None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/parser.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/parser.py
new file mode 100644
index 0000000000000000000000000000000000000000..4fcbf7caa83a474cee2d3ea25da56b0399dd893a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/parser.py
@@ -0,0 +1,533 @@
+"""
+This module started out as largely a copy paste from the stdlib's
+optparse module with the features removed that we do not need from
+optparse because we implement them in Click on a higher level (for
+instance type handling, help formatting and a lot more).
+
+The plan is to remove more and more from here over time.
+
+The reason this is a different module and not optparse from the stdlib
+is that there are differences in 2.x and 3.x about the error messages
+generated and optparse in the stdlib uses gettext for no good reason
+and might cause us issues.
+
+Click uses parts of optparse written by Gregory P. Ward and maintained
+by the Python Software Foundation. This is limited to code in parser.py.
+
+Copyright 2001-2006 Gregory P. Ward. All rights reserved.
+Copyright 2002-2006 Python Software Foundation. All rights reserved.
+"""
+
+# This code uses parts of optparse written by Gregory P. Ward and
+# maintained by the Python Software Foundation.
+# Copyright 2001-2006 Gregory P. Ward
+# Copyright 2002-2006 Python Software Foundation
+from __future__ import annotations
+
+import collections.abc as cabc
+import typing as t
+from collections import deque
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._utils import FLAG_NEEDS_VALUE
+from ._utils import UNSET
+from .exceptions import BadArgumentUsage
+from .exceptions import BadOptionUsage
+from .exceptions import NoSuchOption
+from .exceptions import UsageError
+
+if t.TYPE_CHECKING:
+    from ._utils import T_FLAG_NEEDS_VALUE
+    from ._utils import T_UNSET
+    from .core import Argument as CoreArgument
+    from .core import Context
+    from .core import Option as CoreOption
+    from .core import Parameter as CoreParameter
+
+V = t.TypeVar("V")
+
+
+def _unpack_args(
+    args: cabc.Sequence[str], nargs_spec: cabc.Sequence[int]
+) -> tuple[cabc.Sequence[str | cabc.Sequence[str | T_UNSET] | T_UNSET], list[str]]:
+    """Given an iterable of arguments and an iterable of nargs specifications,
+    it returns a tuple with all the unpacked arguments at the first index
+    and all remaining arguments as the second.
+
+    The nargs specification is the number of arguments that should be consumed
+    or `-1` to indicate that this position should eat up all the remainders.
+
+    Missing items are filled with ``UNSET``.
+    """
+    args = deque(args)
+    nargs_spec = deque(nargs_spec)
+    rv: list[str | tuple[str | T_UNSET, ...] | T_UNSET] = []
+    spos: int | None = None
+
+    def _fetch(c: deque[str]) -> str | T_UNSET:
+        try:
+            if spos is None:
+                return c.popleft()
+            else:
+                return c.pop()
+        except IndexError:
+            return UNSET
+
+    while nargs_spec:
+        if spos is None:
+            nargs = nargs_spec.popleft()
+        else:
+            nargs = nargs_spec.pop()
+
+        if nargs == 1:
+            rv.append(_fetch(args))
+        elif nargs > 1:
+            x: list[str | T_UNSET] = [_fetch(args) for _ in range(nargs)]
+
+            # If we're reversed, we're pulling in the arguments in reverse,
+            # so we need to turn them around.
+            if spos is not None:
+                x.reverse()
+
+            rv.append(tuple(x))
+        elif nargs < 0:
+            if spos is not None:
+                raise TypeError("Cannot have two nargs < 0")
+
+            spos = len(rv)
+            rv.append(UNSET)
+
+    # spos is the position of the wildcard (star).  If it's not `None`,
+    # we fill it with the remainder.
+    if spos is not None:
+        rv[spos] = tuple(args)
+        args = []
+        rv[spos + 1 :] = reversed(rv[spos + 1 :])
+
+    return tuple(rv), list(args)
+
+
+def _split_opt(opt: str) -> tuple[str, str]:
+    first = opt[:1]
+    if first.isalnum():
+        return "", opt
+    if opt[1:2] == first:
+        return opt[:2], opt[2:]
+    return first, opt[1:]
+
+
+def _normalize_opt(opt: str, ctx: Context | None) -> str:
+    if ctx is None or ctx.token_normalize_func is None:
+        return opt
+    prefix, opt = _split_opt(opt)
+    return f"{prefix}{ctx.token_normalize_func(opt)}"
+
+
+class _Option:
+    def __init__(
+        self,
+        obj: CoreOption,
+        opts: cabc.Sequence[str],
+        dest: str | None,
+        action: str | None = None,
+        nargs: int = 1,
+        const: t.Any | None = None,
+    ):
+        self._short_opts = []
+        self._long_opts = []
+        self.prefixes: set[str] = set()
+
+        for opt in opts:
+            prefix, value = _split_opt(opt)
+            if not prefix:
+                raise ValueError(
+                    _("Invalid start character for option ({option})").format(
+                        option=opt
+                    )
+                )
+            self.prefixes.add(prefix[0])
+            if len(prefix) == 1 and len(value) == 1:
+                self._short_opts.append(opt)
+            else:
+                self._long_opts.append(opt)
+                self.prefixes.add(prefix)
+
+        if action is None:
+            action = "store"
+
+        self.dest = dest
+        self.action = action
+        self.nargs = nargs
+        self.const = const
+        self.obj = obj
+
+    @property
+    def takes_value(self) -> bool:
+        return self.action in ("store", "append")
+
+    def process(self, value: t.Any, state: _ParsingState) -> None:
+        if self.action == "store":
+            state.opts[self.dest] = value  # type: ignore
+        elif self.action == "store_const":
+            state.opts[self.dest] = self.const  # type: ignore
+        elif self.action == "append":
+            state.opts.setdefault(self.dest, []).append(value)  # type: ignore
+        elif self.action == "append_const":
+            state.opts.setdefault(self.dest, []).append(self.const)  # type: ignore
+        elif self.action == "count":
+            state.opts[self.dest] = state.opts.get(self.dest, 0) + 1  # type: ignore
+        else:
+            raise ValueError(f"unknown action '{self.action}'")
+        state.order.append(self.obj)
+
+
+class _Argument:
+    def __init__(self, obj: CoreArgument, dest: str | None, nargs: int = 1):
+        self.dest = dest
+        self.nargs = nargs
+        self.obj = obj
+
+    def process(
+        self,
+        value: str | cabc.Sequence[str | T_UNSET] | T_UNSET,
+        state: _ParsingState,
+    ) -> None:
+        if self.nargs > 1:
+            assert isinstance(value, cabc.Sequence)
+            holes = sum(x is UNSET for x in value)
+            if holes == len(value):
+                value = UNSET
+            elif holes != 0:
+                raise BadArgumentUsage(
+                    _("Argument {name!r} takes {nargs} values.").format(
+                        name=self.dest, nargs=self.nargs
+                    )
+                )
+
+        # We failed to collect any argument value so we consider the argument as unset.
+        if value == ():
+            value = UNSET
+
+        state.opts[self.dest] = value  # type: ignore
+        state.order.append(self.obj)
+
+
+class _ParsingState:
+    def __init__(self, rargs: list[str]) -> None:
+        self.opts: dict[str, t.Any] = {}
+        self.largs: list[str] = []
+        self.rargs = rargs
+        self.order: list[CoreParameter] = []
+
+
+class _OptionParser:
+    """The option parser is an internal class that is ultimately used to
+    parse options and arguments.  It's modelled after optparse and brings
+    a similar but vastly simplified API.  It should generally not be used
+    directly as the high level Click classes wrap it for you.
+
+    It's not nearly as extensible as optparse or argparse as it does not
+    implement features that are implemented on a higher level (such as
+    types or defaults).
+
+    :param ctx: optionally the :class:`~click.Context` where this parser
+                should go with.
+
+    .. deprecated:: 8.2
+        Will be removed in Click 9.0.
+    """
+
+    def __init__(self, ctx: Context | None = None) -> None:
+        #: The :class:`~click.Context` for this parser.  This might be
+        #: `None` for some advanced use cases.
+        self.ctx = ctx
+        #: This controls how the parser deals with interspersed arguments.
+        #: If this is set to `False`, the parser will stop on the first
+        #: non-option.  Click uses this to implement nested subcommands
+        #: safely.
+        self.allow_interspersed_args: bool = True
+        #: This tells the parser how to deal with unknown options.  By
+        #: default it will error out (which is sensible), but there is a
+        #: second mode where it will ignore it and continue processing
+        #: after shifting all the unknown options into the resulting args.
+        self.ignore_unknown_options: bool = False
+
+        if ctx is not None:
+            self.allow_interspersed_args = ctx.allow_interspersed_args
+            self.ignore_unknown_options = ctx.ignore_unknown_options
+
+        self._short_opt: dict[str, _Option] = {}
+        self._long_opt: dict[str, _Option] = {}
+        self._opt_prefixes = {"-", "--"}
+        self._args: list[_Argument] = []
+
+    def add_option(
+        self,
+        obj: CoreOption,
+        opts: cabc.Sequence[str],
+        dest: str | None,
+        action: str | None = None,
+        nargs: int = 1,
+        const: t.Any | None = None,
+    ) -> None:
+        """Adds a new option named `dest` to the parser.  The destination
+        is not inferred (unlike with optparse) and needs to be explicitly
+        provided.  Action can be any of ``store``, ``store_const``,
+        ``append``, ``append_const`` or ``count``.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        opts = [_normalize_opt(opt, self.ctx) for opt in opts]
+        option = _Option(obj, opts, dest, action=action, nargs=nargs, const=const)
+        self._opt_prefixes.update(option.prefixes)
+        for opt in option._short_opts:
+            self._short_opt[opt] = option
+        for opt in option._long_opts:
+            self._long_opt[opt] = option
+
+    def add_argument(self, obj: CoreArgument, dest: str | None, nargs: int = 1) -> None:
+        """Adds a positional argument named `dest` to the parser.
+
+        The `obj` can be used to identify the option in the order list
+        that is returned from the parser.
+        """
+        self._args.append(_Argument(obj, dest=dest, nargs=nargs))
+
+    def parse_args(
+        self, args: list[str]
+    ) -> tuple[dict[str, t.Any], list[str], list[CoreParameter]]:
+        """Parses positional arguments and returns ``(values, args, order)``
+        for the parsed options and arguments as well as the leftover
+        arguments if there are any.  The order is a list of objects as they
+        appear on the command line.  If arguments appear multiple times they
+        will be memorized multiple times as well.
+        """
+        state = _ParsingState(args)
+        try:
+            self._process_args_for_options(state)
+            self._process_args_for_args(state)
+        except UsageError:
+            if self.ctx is None or not self.ctx.resilient_parsing:
+                raise
+        return state.opts, state.largs, state.order
+
+    def _process_args_for_args(self, state: _ParsingState) -> None:
+        pargs, args = _unpack_args(
+            state.largs + state.rargs, [x.nargs for x in self._args]
+        )
+
+        for idx, arg in enumerate(self._args):
+            arg.process(pargs[idx], state)
+
+        state.largs = args
+        state.rargs = []
+
+    def _process_args_for_options(self, state: _ParsingState) -> None:
+        while state.rargs:
+            arg = state.rargs.pop(0)
+            arglen = len(arg)
+            # Double dashes always handled explicitly regardless of what
+            # prefixes are valid.
+            if arg == "--":
+                return
+            elif arg[:1] in self._opt_prefixes and arglen > 1:
+                self._process_opts(arg, state)
+            elif self.allow_interspersed_args:
+                state.largs.append(arg)
+            else:
+                state.rargs.insert(0, arg)
+                return
+
+        # Say this is the original argument list:
+        # [arg0, arg1, ..., arg(i-1), arg(i), arg(i+1), ..., arg(N-1)]
+        #                            ^
+        # (we are about to process arg(i)).
+        #
+        # Then rargs is [arg(i), ..., arg(N-1)] and largs is a *subset* of
+        # [arg0, ..., arg(i-1)] (any options and their arguments will have
+        # been removed from largs).
+        #
+        # The while loop will usually consume 1 or more arguments per pass.
+        # If it consumes 1 (eg. arg is an option that takes no arguments),
+        # then after _process_arg() is done the situation is:
+        #
+        #   largs = subset of [arg0, ..., arg(i)]
+        #   rargs = [arg(i+1), ..., arg(N-1)]
+        #
+        # If allow_interspersed_args is false, largs will always be
+        # *empty* -- still a subset of [arg0, ..., arg(i-1)], but
+        # not a very interesting subset!
+
+    def _match_long_opt(
+        self, opt: str, explicit_value: str | None, state: _ParsingState
+    ) -> None:
+        if opt not in self._long_opt:
+            raise NoSuchOption(opt, possibilities=self._long_opt, ctx=self.ctx)
+
+        option = self._long_opt[opt]
+        if option.takes_value:
+            # At this point it's safe to modify rargs by injecting the
+            # explicit value, because no exception is raised in this
+            # branch.  This means that the inserted value will be fully
+            # consumed.
+            if explicit_value is not None:
+                state.rargs.insert(0, explicit_value)
+
+            value = self._get_value_from_state(opt, option, state)
+
+        elif explicit_value is not None:
+            raise BadOptionUsage(
+                opt, _("Option {name!r} does not take a value.").format(name=opt)
+            )
+
+        else:
+            value = UNSET
+
+        option.process(value, state)
+
+    def _match_short_opt(self, arg: str, state: _ParsingState) -> None:
+        stop = False
+        i = 1
+        prefix = arg[0]
+        unknown_options = []
+
+        for ch in arg[1:]:
+            opt = _normalize_opt(f"{prefix}{ch}", self.ctx)
+            option = self._short_opt.get(opt)
+            i += 1
+
+            if not option:
+                if self.ignore_unknown_options:
+                    unknown_options.append(ch)
+                    continue
+                raise NoSuchOption(opt, ctx=self.ctx)
+            if option.takes_value:
+                # Any characters left in arg?  Pretend they're the
+                # next arg, and stop consuming characters of arg.
+                if i < len(arg):
+                    state.rargs.insert(0, arg[i:])
+                    stop = True
+
+                value = self._get_value_from_state(opt, option, state)
+
+            else:
+                value = UNSET
+
+            option.process(value, state)
+
+            if stop:
+                break
+
+        # If we got any unknown options we recombine the string of the
+        # remaining options and re-attach the prefix, then report that
+        # to the state as new large.  This way there is basic combinatorics
+        # that can be achieved while still ignoring unknown arguments.
+        if self.ignore_unknown_options and unknown_options:
+            state.largs.append(f"{prefix}{''.join(unknown_options)}")
+
+    def _get_value_from_state(
+        self, option_name: str, option: _Option, state: _ParsingState
+    ) -> str | cabc.Sequence[str] | T_UNSET | T_FLAG_NEEDS_VALUE:
+        nargs = option.nargs
+
+        value: str | cabc.Sequence[str] | T_UNSET | T_FLAG_NEEDS_VALUE
+
+        if len(state.rargs) < nargs:
+            if option.obj._flag_needs_value:
+                # Option allows omitting the value.
+                value = FLAG_NEEDS_VALUE
+            else:
+                raise BadOptionUsage(
+                    option_name,
+                    ngettext(
+                        "Option {name!r} requires an argument.",
+                        "Option {name!r} requires {nargs} arguments.",
+                        nargs,
+                    ).format(name=option_name, nargs=nargs),
+                )
+        elif nargs == 1:
+            next_rarg = state.rargs[0]
+
+            if (
+                option.obj._flag_needs_value
+                and isinstance(next_rarg, str)
+                and next_rarg[:1] in self._opt_prefixes
+                and len(next_rarg) > 1
+            ):
+                # The next arg looks like the start of an option, don't
+                # use it as the value if omitting the value is allowed.
+                value = FLAG_NEEDS_VALUE
+            else:
+                value = state.rargs.pop(0)
+        else:
+            value = tuple(state.rargs[:nargs])
+            del state.rargs[:nargs]
+
+        return value
+
+    def _process_opts(self, arg: str, state: _ParsingState) -> None:
+        explicit_value = None
+        # Long option handling happens in two parts.  The first part is
+        # supporting explicitly attached values.  In any case, we will try
+        # to long match the option first.
+        if "=" in arg:
+            long_opt, explicit_value = arg.split("=", 1)
+        else:
+            long_opt = arg
+        norm_long_opt = _normalize_opt(long_opt, self.ctx)
+
+        # At this point we will match the (assumed) long option through
+        # the long option matching code.  Note that this allows options
+        # like "-foo" to be matched as long options.
+        try:
+            self._match_long_opt(norm_long_opt, explicit_value, state)
+        except NoSuchOption:
+            # At this point the long option matching failed, and we need
+            # to try with short options.  However there is a special rule
+            # which says, that if we have a two character options prefix
+            # (applies to "--foo" for instance), we do not dispatch to the
+            # short option code and will instead raise the no option
+            # error.
+            if arg[:2] not in self._opt_prefixes:
+                self._match_short_opt(arg, state)
+                return
+
+            if not self.ignore_unknown_options:
+                raise
+
+            state.largs.append(arg)
+
+
+def __getattr__(name: str) -> object:
+    import warnings
+
+    if name in {
+        "OptionParser",
+        "Argument",
+        "Option",
+        "split_opt",
+        "normalize_opt",
+        "ParsingState",
+    }:
+        warnings.warn(
+            f"'parser.{name}' is deprecated and will be removed in Click 9.0."
+            " The old parser is available in 'optparse'.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return globals()[f"_{name}"]
+
+    if name == "split_arg_string":
+        from .shell_completion import split_arg_string
+
+        warnings.warn(
+            "Importing 'parser.split_arg_string' is deprecated, it will only be"
+            " available in 'shell_completion' in Click 9.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return split_arg_string
+
+    raise AttributeError(name)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/shell_completion.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/shell_completion.py
new file mode 100644
index 0000000000000000000000000000000000000000..8a2668b09f1525ae95e814fa92a23bfdbee2c21d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/shell_completion.py
@@ -0,0 +1,801 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import os
+import re
+import typing as t
+from gettext import gettext as _
+
+from .core import Argument
+from .core import Command
+from .core import Context
+from .core import Group
+from .core import Option
+from .core import Parameter
+from .core import ParameterSource
+from .utils import echo
+
+
+def shell_complete(
+    cli: Command,
+    ctx_args: cabc.MutableMapping[str, t.Any],
+    prog_name: str,
+    complete_var: str,
+    instruction: str,
+) -> t.Literal[0, 1]:
+    """Perform shell completion for the given CLI program.
+
+    :param cli: Command being called.
+    :param ctx_args: Extra arguments to pass to
+        ``cli.make_context``.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+    :param instruction: Value of ``complete_var`` with the completion
+        instruction and shell, in the form ``instruction_shell``.
+    :return: Status code to exit with.
+    """
+    shell, _, instruction = instruction.partition("_")
+    comp_cls = get_completion_class(shell)
+
+    if comp_cls is None:
+        return 1
+
+    comp = comp_cls(cli, ctx_args, prog_name, complete_var)
+
+    # Write bytes, otherwise Windows text stdout translates LF to CRLF and breaks.
+    if instruction == "source":
+        echo(comp.source().encode(), nl=False)
+        return 0
+
+    if instruction == "complete":
+        echo(comp.complete().encode())
+        return 0
+
+    return 1
+
+
+if t.TYPE_CHECKING:
+    from typing_extensions import TypeVar
+
+    # `Any` is used as default for backwards compatibility (instead of e.g. `str`)
+    _ValueT_co = TypeVar("_ValueT_co", covariant=True, default=t.Any)
+else:
+    _ValueT_co = t.TypeVar("_ValueT_co", covariant=True)
+
+
+class CompletionItem(t.Generic[_ValueT_co]):
+    """Represents a completion value and metadata about the value. The
+    default metadata is ``type`` to indicate special shell handling,
+    and ``help`` if a shell supports showing a help string next to the
+    value.
+
+    Arbitrary parameters can be passed when creating the object, and
+    accessed using ``item.attr``. If an attribute wasn't passed,
+    accessing it returns ``None``.
+
+    :param value: The completion suggestion.
+    :param type: Tells the shell script to provide special completion
+        support for the type. Click uses ``"dir"`` and ``"file"``.
+    :param help: String shown next to the value if supported.
+    :param kwargs: Arbitrary metadata. The built-in implementations
+        don't use this, but custom type completions paired with custom
+        shell support could use it.
+    """
+
+    __slots__ = ("value", "type", "help", "_info")
+
+    def __init__(
+        self,
+        value: _ValueT_co,
+        type: str = "plain",
+        help: str | None = None,
+        **kwargs: t.Any,
+    ) -> None:
+        self.value: _ValueT_co = value
+        self.type: str = type
+        self.help: str | None = help
+        self._info = kwargs
+
+    def __getattr__(self, name: str) -> t.Any:
+        return self._info.get(name)
+
+
+# Only Bash >= 4.4 has the nosort option.
+_SOURCE_BASH = """\
+%(complete_func)s() {
+    local IFS=$'\\n'
+    local response
+
+    response=$(env COMP_WORDS="${COMP_WORDS[*]}" COMP_CWORD=$COMP_CWORD \
+%(complete_var)s=bash_complete $1)
+
+    for completion in $response; do
+        IFS=',' read type value <<< "$completion"
+
+        if [[ $type == 'dir' ]]; then
+            COMPREPLY=()
+            compopt -o dirnames
+        elif [[ $type == 'file' ]]; then
+            COMPREPLY=()
+            compopt -o default
+        elif [[ $type == 'plain' ]]; then
+            COMPREPLY+=($value)
+        fi
+    done
+
+    return 0
+}
+
+%(complete_func)s_setup() {
+    complete -o nosort -F %(complete_func)s %(prog_name)s
+}
+
+%(complete_func)s_setup;
+"""
+
+# See ZshComplete.format_completion below, and issue #2703, before
+# changing this script.
+#
+# (TL;DR: _describe is picky about the format, but this Zsh script snippet
+# is already widely deployed.  So freeze this script, and use clever-ish
+# handling of colons in ZshComplet.format_completion.)
+_SOURCE_ZSH = """\
+#compdef %(prog_name)s
+
+%(complete_func)s() {
+    local -a completions
+    local -a completions_with_descriptions
+    local -a response
+    (( ! $+commands[%(prog_name)s] )) && return 1
+
+    response=("${(@f)$(env COMP_WORDS="${words[*]}" COMP_CWORD=$((CURRENT-1)) \
+%(complete_var)s=zsh_complete %(prog_name)s)}")
+
+    for type key descr in ${response}; do
+        if [[ "$type" == "plain" ]]; then
+            if [[ "$descr" == "_" ]]; then
+                completions+=("$key")
+            else
+                completions_with_descriptions+=("$key":"$descr")
+            fi
+        elif [[ "$type" == "dir" ]]; then
+            _path_files -/
+        elif [[ "$type" == "file" ]]; then
+            _path_files -f
+        fi
+    done
+
+    if [ -n "$completions_with_descriptions" ]; then
+        _describe -V unsorted completions_with_descriptions -U
+    fi
+
+    if [ -n "$completions" ]; then
+        compadd -U -V unsorted -a completions
+    fi
+}
+
+if [[ $zsh_eval_context[-1] == loadautofunc ]]; then
+    # autoload from fpath, call function directly
+    %(complete_func)s "$@"
+else
+    # eval/source/. command, register function for later
+    compdef %(complete_func)s %(prog_name)s
+fi
+"""
+
+_SOURCE_FISH = """\
+function %(complete_func)s;
+    set -l response (env %(complete_var)s=fish_complete COMP_WORDS=(commandline -cp) \
+COMP_CWORD=(commandline -t) %(prog_name)s);
+
+    for completion in $response;
+        set -l metadata (string split "," $completion);
+
+        if test $metadata[1] = "dir";
+            __fish_complete_directories $metadata[2];
+        else if test $metadata[1] = "file";
+            __fish_complete_path $metadata[2];
+        else if test $metadata[1] = "plain";
+            echo $metadata[2];
+        end;
+    end;
+end;
+
+complete --no-files --command %(prog_name)s --arguments \
+"(%(complete_func)s)";
+"""
+
+# Compatible with Windows PowerShell 5.1+ and PowerShell (pwsh) 7+.
+# Uses Register-ArgumentCompleter -Native, which receives the command AST
+# as parsed by PowerShell. The command text is forwarded verbatim through
+# COMP_WORDS so the Python side can reuse the same shlex-based splitting
+# used by the bash/zsh completers.
+_SOURCE_POWERSHELL = """\
+Register-ArgumentCompleter -Native -CommandName %(prog_name)s -ScriptBlock {
+    param($wordToComplete, $commandAst, $cursorPosition)
+
+    $prev_complete = $env:%(complete_var)s
+    $prev_words = $env:COMP_WORDS
+    $prev_cword = $env:COMP_CWORD
+
+    $env:%(complete_var)s = 'powershell_complete'
+    $env:COMP_WORDS = $commandAst.ToString()
+    if ($wordToComplete) {
+        $env:COMP_CWORD = $commandAst.CommandElements.Count - 1
+    } else {
+        $env:COMP_CWORD = $commandAst.CommandElements.Count
+    }
+
+    try {
+        $response = & %(prog_name)s 2>$null
+    } finally {
+        $env:%(complete_var)s = $prev_complete
+        $env:COMP_WORDS = $prev_words
+        $env:COMP_CWORD = $prev_cword
+    }
+
+    if (-not $response) { return }
+
+    $prefix = "$wordToComplete*"
+    $lines = $response -split "`n"
+    for ($i = 0; $i + 2 -lt $lines.Count; $i += 3) {
+        $type = $lines[$i]
+        $value = $lines[$i + 1]
+        $descr = $lines[$i + 2]
+        if (-not $type) { continue }
+
+        if ($type -eq 'plain') {
+            $tip = if ($descr -and $descr -ne '_') { $descr } else { $value }
+            [System.Management.Automation.CompletionResult]::new(
+                $value, $value, 'ParameterValue', $tip)
+        } elseif ($type -eq 'dir') {
+            Get-ChildItem -Directory -Path $prefix -ErrorAction SilentlyContinue |
+                ForEach-Object {
+                    [System.Management.Automation.CompletionResult]::new(
+                        $_.FullName, $_.Name, 'ProviderContainer', $_.FullName)
+                }
+        } elseif ($type -eq 'file') {
+            Get-ChildItem -Path $prefix -ErrorAction SilentlyContinue |
+                ForEach-Object {
+                    $kind = 'ProviderItem'
+                    if ($_.PSIsContainer) { $kind = 'ProviderContainer' }
+                    [System.Management.Automation.CompletionResult]::new(
+                        $_.FullName, $_.Name, $kind, $_.FullName)
+                }
+        }
+    }
+}
+"""
+
+
+class _SourceVarsDict(t.TypedDict):
+    complete_func: str
+    complete_var: str
+    prog_name: str
+
+
+class ShellComplete:
+    """Base class for providing shell completion support. A subclass for
+    a given shell will override attributes and methods to implement the
+    completion instructions (``source`` and ``complete``).
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param complete_var: Name of the environment variable that holds
+        the completion instruction.
+
+    .. versionadded:: 8.0
+    """
+
+    name: t.ClassVar[str]
+    """Name to register the shell as with :func:`add_completion_class`.
+    This is used in completion instructions (``{name}_source`` and
+    ``{name}_complete``).
+    """
+
+    source_template: t.ClassVar[str]
+    """Completion script template formatted by :meth:`source`. This must
+    be provided by subclasses.
+    """
+
+    cli: Command
+    ctx_args: cabc.MutableMapping[str, t.Any]
+    prog_name: str
+    complete_var: str
+
+    def __init__(
+        self,
+        cli: Command,
+        ctx_args: cabc.MutableMapping[str, t.Any],
+        prog_name: str,
+        complete_var: str,
+    ) -> None:
+        self.cli = cli
+        self.ctx_args = ctx_args
+        self.prog_name = prog_name
+        self.complete_var = complete_var
+
+    @property
+    def func_name(self) -> str:
+        """The name of the shell function defined by the completion
+        script.
+        """
+        safe_name = re.sub(r"\W*", "", self.prog_name.replace("-", "_"), flags=re.ASCII)
+        return f"_{safe_name}_completion"
+
+    def source_vars(self) -> _SourceVarsDict:
+        """Vars for formatting :attr:`source_template`.
+
+        By default this provides ``complete_func``, ``complete_var``,
+        and ``prog_name``.
+        """
+        return {
+            "complete_func": self.func_name,
+            "complete_var": self.complete_var,
+            "prog_name": self.prog_name,
+        }
+
+    def source(self) -> str:
+        """Produce the shell script that defines the completion
+        function. By default this ``%``-style formats
+        :attr:`source_template` with the dict returned by
+        :meth:`source_vars`.
+        """
+        return self.source_template % self.source_vars()
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        """Use the env vars defined by the shell script to return a
+        tuple of ``args, incomplete``. This must be implemented by
+        subclasses.
+        """
+        raise NotImplementedError
+
+    def get_completions(
+        self, args: list[str], incomplete: str
+    ) -> list[CompletionItem[str]]:
+        """Determine the context and last complete command or parameter
+        from the complete args. Call that object's ``shell_complete``
+        method to get the completions for the incomplete value.
+
+        :param args: List of complete args before the incomplete value.
+        :param incomplete: Value being completed. May be empty.
+        """
+        ctx = _resolve_context(self.cli, self.ctx_args, self.prog_name, args)
+        obj, incomplete = _resolve_incomplete(ctx, args, incomplete)
+        return obj.shell_complete(ctx, incomplete)
+
+    def format_completion(self, item: CompletionItem[str]) -> str:
+        """Format a completion item into the form recognized by the
+        shell script. This must be implemented by subclasses.
+
+        :param item: Completion item to format.
+        """
+        raise NotImplementedError
+
+    def complete(self) -> str:
+        """Produce the completion data to send back to the shell.
+
+        By default this calls :meth:`get_completion_args`, gets the
+        completions, then calls :meth:`format_completion` for each
+        completion.
+        """
+        args, incomplete = self.get_completion_args()
+        completions = self.get_completions(args, incomplete)
+        out = [self.format_completion(item) for item in completions]
+        return "\n".join(out)
+
+
+class BashComplete(ShellComplete):
+    """Shell completion for Bash."""
+
+    name: t.ClassVar[str] = "bash"
+    source_template: t.ClassVar[str] = _SOURCE_BASH
+
+    @staticmethod
+    def _check_version() -> None:
+        import shutil
+        import subprocess
+
+        bash_exe = shutil.which("bash")
+
+        if bash_exe is None:
+            match = None
+        else:
+            output = subprocess.run(
+                [bash_exe, "--norc", "-c", 'echo "${BASH_VERSION}"'],
+                stdout=subprocess.PIPE,
+            )
+            match = re.search(r"^(\d+)\.(\d+)\.\d+", output.stdout.decode())
+
+        if match is not None:
+            major, minor = match.groups()
+
+            if major < "4" or major == "4" and minor < "4":
+                echo(
+                    _(
+                        "Shell completion is not supported for Bash"
+                        " versions older than 4.4."
+                    ),
+                    err=True,
+                )
+        else:
+            echo(
+                _("Couldn't detect Bash version, shell completion is not supported."),
+                err=True,
+            )
+
+    def source(self) -> str:
+        self._check_version()
+        return super().source()
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem[t.Any]) -> str:
+        return f"{item.type},{item.value}"
+
+
+class ZshComplete(ShellComplete):
+    """Shell completion for Zsh."""
+
+    name: t.ClassVar[str] = "zsh"
+    source_template: t.ClassVar[str] = _SOURCE_ZSH
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem[str]) -> str:
+        help_ = item.help or "_"
+        # The zsh completion script uses `_describe` on items with help
+        # texts (which splits the item help from the item value at the
+        # first unescaped colon) and `compadd` on items without help
+        # text (which uses the item value as-is and does not support
+        # colon escaping).  So escape colons in the item value if and
+        # only if the item help is not the sentinel "_" value, as used
+        # by the completion script.
+        #
+        # (The zsh completion script is potentially widely deployed, and
+        # thus harder to fix than this method.)
+        #
+        # See issue #1812 and issue #2703 for further context.
+        value = item.value.replace(":", r"\:") if help_ != "_" else item.value
+        return f"{item.type}\n{value}\n{help_}"
+
+
+class FishComplete(ShellComplete):
+    """Shell completion for Fish."""
+
+    name: t.ClassVar[str] = "fish"
+    source_template: t.ClassVar[str] = _SOURCE_FISH
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        incomplete = os.environ["COMP_CWORD"]
+        if incomplete:
+            incomplete = split_arg_string(incomplete)[0]
+        args = cwords[1:]
+
+        # Fish stores the partial word in both COMP_WORDS and
+        # COMP_CWORD, remove it from complete args.
+        if incomplete and args and args[-1] == incomplete:
+            args.pop()
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem[str]) -> str:
+        """
+        .. versionchanged:: 8.4.2
+            Escape newlines and replace tabs with spaces in the help text to
+            fix completion errors with multi-line help strings.
+        """
+        # According to https://fishshell.com/docs/current/cmds/complete.html
+        # Command substitutions found in ARGUMENTS should return a newline-
+        # separated list of arguments, and each argument may optionally have a tab
+        # character followed by the argument description.
+        if item.help:
+            help_ = item.help.replace("\n", "\\n").replace("\t", " ")
+            return f"{item.type},{item.value}\t{help_}"
+
+        return f"{item.type},{item.value}"
+
+
+class PowerShellComplete(ShellComplete):
+    """Shell completion for PowerShell (Windows PowerShell 5.1+ and pwsh 7+).
+
+    .. versionadded:: 8.5.0
+    """
+
+    name: t.ClassVar[str] = "powershell"
+    source_template: t.ClassVar[str] = _SOURCE_POWERSHELL
+
+    def get_completion_args(self) -> tuple[list[str], str]:
+        cwords = split_arg_string(os.environ["COMP_WORDS"])
+        cword = int(os.environ["COMP_CWORD"])
+        args = cwords[1:cword]
+
+        try:
+            incomplete = cwords[cword]
+        except IndexError:
+            incomplete = ""
+
+        return args, incomplete
+
+    def format_completion(self, item: CompletionItem[str]) -> str:
+        # PowerShell parses the response by splitting on newlines and
+        # consuming three lines per completion (type, value, help).
+        # Multi-line help text would break that framing, so collapse
+        # newlines and carriage returns to spaces. The literal "_"
+        # sentinel matches what ZshComplete uses for "no help text".
+        if item.help:
+            help_ = item.help.replace("\r", " ").replace("\n", " ")
+        else:
+            help_ = "_"
+        return f"{item.type}\n{item.value}\n{help_}"
+
+
+_available_shells: t.Final[dict[str, type[ShellComplete]]] = {
+    "bash": BashComplete,
+    "fish": FishComplete,
+    "powershell": PowerShellComplete,
+    "zsh": ZshComplete,
+}
+
+_ShellCompleteT = t.TypeVar("_ShellCompleteT", bound="ShellComplete")
+
+
+def add_completion_class(
+    cls: type[_ShellCompleteT], name: str | None = None
+) -> type[_ShellCompleteT]:
+    """Register a :class:`ShellComplete` subclass under the given name.
+    The name will be provided by the completion instruction environment
+    variable during completion.
+
+    :param cls: The completion class that will handle completion for the
+        shell.
+    :param name: Name to register the class under. Defaults to the
+        class's ``name`` attribute.
+    """
+    if name is None:
+        name = cls.name
+
+    _available_shells[name] = cls
+
+    return cls
+
+
+@t.overload
+def get_completion_class(shell: t.Literal["bash"]) -> type[BashComplete]: ...
+@t.overload
+def get_completion_class(shell: t.Literal["fish"]) -> type[FishComplete]: ...
+@t.overload
+def get_completion_class(shell: t.Literal["zsh"]) -> type[ZshComplete]: ...
+@t.overload
+def get_completion_class(shell: str) -> type[ShellComplete] | None: ...
+def get_completion_class(shell: str) -> type[ShellComplete] | None:
+    """Look up a registered :class:`ShellComplete` subclass by the name
+    provided by the completion instruction environment variable. If the
+    name isn't registered, returns ``None``.
+
+    :param shell: Name the class is registered under.
+    """
+    return _available_shells.get(shell)
+
+
+def split_arg_string(string: str) -> list[str]:
+    """Split an argument string as with :func:`shlex.split`, but don't
+    fail if the string is incomplete. Ignores a missing closing quote or
+    incomplete escape sequence and uses the partial token as-is.
+
+    .. code-block:: python
+
+        split_arg_string("example 'my file")
+        ["example", "my file"]
+
+        split_arg_string("example my\\")
+        ["example", "my"]
+
+    :param string: String to split.
+
+    .. versionchanged:: 8.2
+        Moved to ``shell_completion`` from ``parser``.
+    """
+    import shlex
+
+    lex = shlex.shlex(string, posix=True)
+    lex.whitespace_split = True
+    lex.commenters = ""
+    out: list[str] = []
+
+    try:
+        out.extend(lex)
+    except ValueError:
+        # Raised when end-of-string is reached in an invalid state. Use
+        # the partial token as-is. The quote or escape character is in
+        # lex.state, not lex.token.
+        out.append(lex.token)
+
+    return out
+
+
+def _is_incomplete_argument(ctx: Context, param: Parameter) -> bool:
+    """Determine if the given parameter is an argument that can still
+    accept values.
+
+    :param ctx: Invocation context for the command represented by the
+        parsed complete args.
+    :param param: Argument object being checked.
+    """
+    if not isinstance(param, Argument):
+        return False
+
+    value = ctx.params.get(param.name)
+    return (
+        param.nargs == -1
+        or ctx.get_parameter_source(param.name) is not ParameterSource.COMMANDLINE
+        or (
+            param.nargs > 1
+            and isinstance(value, (tuple, list))
+            and len(value) < param.nargs
+        )
+    )
+
+
+def _start_of_option(ctx: Context, value: str) -> bool:
+    """Check if the value looks like the start of an option."""
+    if not value:
+        return False
+
+    c = value[0]
+    return c in ctx._opt_prefixes
+
+
+def _is_incomplete_option(ctx: Context, args: list[str], param: Parameter) -> bool:
+    """Determine if the given parameter is an option that needs a value.
+
+    :param args: List of complete args before the incomplete value.
+    :param param: Option object being checked.
+    """
+    if not isinstance(param, Option):
+        return False
+
+    if param.is_flag or param.count:
+        return False
+
+    last_option = None
+
+    for index, arg in enumerate(reversed(args)):
+        if index + 1 > param.nargs:
+            break
+
+        if _start_of_option(ctx, arg):
+            last_option = arg
+            break
+
+    return last_option is not None and last_option in param.opts
+
+
+def _resolve_context(
+    cli: Command,
+    ctx_args: cabc.MutableMapping[str, t.Any],
+    prog_name: str,
+    args: list[str],
+) -> Context:
+    """Produce the context hierarchy starting with the command and
+    traversing the complete arguments. This only follows the commands,
+    it doesn't trigger input prompts or callbacks.
+
+    :param cli: Command being called.
+    :param prog_name: Name of the executable in the shell.
+    :param args: List of complete args before the incomplete value.
+    """
+    ctx_args["resilient_parsing"] = True
+    with cli.make_context(prog_name, args.copy(), **ctx_args) as ctx:
+        args = ctx._protected_args + ctx.args
+
+        while args:
+            command = ctx.command
+
+            if isinstance(command, Group):
+                if not command.chain:
+                    name, cmd, args = command.resolve_command(ctx, args)
+
+                    if cmd is None:
+                        return ctx
+
+                    with cmd.make_context(
+                        name, args, parent=ctx, resilient_parsing=True
+                    ) as sub_ctx:
+                        ctx = sub_ctx
+                        args = ctx._protected_args + ctx.args
+                else:
+                    sub_ctx = ctx
+
+                    while args:
+                        name, cmd, args = command.resolve_command(ctx, args)
+
+                        if cmd is None:
+                            return ctx
+
+                        with cmd.make_context(
+                            name,
+                            args,
+                            parent=ctx,
+                            allow_extra_args=True,
+                            allow_interspersed_args=False,
+                            resilient_parsing=True,
+                        ) as sub_sub_ctx:
+                            sub_ctx = sub_sub_ctx
+                            args = sub_ctx.args
+
+                    ctx = sub_ctx
+                    args = [*sub_ctx._protected_args, *sub_ctx.args]
+            else:
+                break
+
+    return ctx
+
+
+def _resolve_incomplete(
+    ctx: Context, args: list[str], incomplete: str
+) -> tuple[Command | Parameter, str]:
+    """Find the Click object that will handle the completion of the
+    incomplete value. Return the object and the incomplete value.
+
+    :param ctx: Invocation context for the command represented by
+        the parsed complete args.
+    :param args: List of complete args before the incomplete value.
+    :param incomplete: Value being completed. May be empty.
+    """
+    # Different shells treat an "=" between a long option name and
+    # value differently. Might keep the value joined, return the "="
+    # as a separate item, or return the split name and value. Always
+    # split and discard the "=" to make completion easier.
+    if incomplete == "=":
+        incomplete = ""
+    elif "=" in incomplete and _start_of_option(ctx, incomplete):
+        name, _, incomplete = incomplete.partition("=")
+        args.append(name)
+
+    # The "--" marker tells Click to stop treating values as options
+    # even if they start with the option character. If it hasn't been
+    # given and the incomplete arg looks like an option, the current
+    # command will provide option name completions.
+    if "--" not in args and _start_of_option(ctx, incomplete):
+        return ctx.command, incomplete
+
+    params = ctx.command.get_params(ctx)
+
+    # If the last complete arg is an option name with an incomplete
+    # value, the option will provide value completions.
+    for param in params:
+        if _is_incomplete_option(ctx, args, param):
+            return param, incomplete
+
+    # It's not an option name or value. The first argument without a
+    # parsed value will provide value completions.
+    for param in params:
+        if _is_incomplete_argument(ctx, param):
+            return param, incomplete
+
+    # There were no unparsed arguments, the command may be a group that
+    # will provide command name completions.
+    return ctx.command, incomplete
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/termui.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/termui.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1315f23744ee9055126971c1cf350428aeab06b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/termui.py
@@ -0,0 +1,1014 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import inspect
+import io
+import itertools
+import os
+import re
+import sys
+import typing as t
+from contextlib import AbstractContextManager
+from contextlib import redirect_stdout
+from gettext import gettext as _
+
+from . import _compat
+from ._compat import isatty
+from ._compat import strip_ansi
+from .exceptions import Abort
+from .exceptions import UsageError
+from .globals import resolve_color_default
+from .types import Choice
+from .types import convert_type
+from .types import ParamType
+from .utils import _LazyFile
+from .utils import echo
+
+if t.TYPE_CHECKING:
+    from ._termui_impl import ProgressBar
+
+V = t.TypeVar("V")
+
+# The prompt functions to use.  The doc tools currently override these
+# functions to customize how they work.
+visible_prompt_func: t.Callable[[str], str] = input
+
+_ansi_colors = {
+    "black": 30,
+    "red": 31,
+    "green": 32,
+    "yellow": 33,
+    "blue": 34,
+    "magenta": 35,
+    "cyan": 36,
+    "white": 37,
+    "reset": 39,
+    "bright_black": 90,
+    "bright_red": 91,
+    "bright_green": 92,
+    "bright_yellow": 93,
+    "bright_blue": 94,
+    "bright_magenta": 95,
+    "bright_cyan": 96,
+    "bright_white": 97,
+}
+_ansi_reset_all = "\033[0m"
+
+
+_HIDDEN_INPUT_MASK = "'***'"
+
+
+def _mask_hidden_input(message: str, value: str) -> str:
+    """Replace occurrences of ``value`` in ``message`` with a fixed mask.
+
+    Both ``repr(value)`` (the form built-in :class:`ParamType` errors use
+    via ``{value!r}``) and the raw value are masked. The raw-value pass
+    uses word-boundary lookarounds so a substring like ``"1"`` does not
+    match inside ``"10"``, and ``"ent"`` does not match inside
+    ``"Authentication"``. The empty string is skipped to avoid matching
+    at every boundary.
+    """
+    message = message.replace(repr(value), _HIDDEN_INPUT_MASK)
+    if value:
+        message = re.sub(
+            rf"(?<!\w){re.escape(value)}(?!\w)", _HIDDEN_INPUT_MASK, message
+        )
+    return message
+
+
+def hidden_prompt_func(prompt: str) -> str:
+    import getpass
+
+    return getpass.getpass(prompt)
+
+
+def _readline_prompt(func: t.Callable[[str], str], text: str, err: bool) -> str:
+    """Call a prompt function, passing the full prompt so readline can
+    handle line editing and cursor positioning correctly.
+
+    The prompt is handed to *func* (such as :func:`input`) rather than
+    written through :func:`echo`, so it has to strip ANSI color and style
+    codes itself when the destination stream does not support them. Without
+    this the prompt would keep codes that :func:`echo` removes from the
+    rest of the output.
+    """
+    stream = sys.stderr if err else sys.stdout
+
+    # Look up ``should_strip_ansi`` on the module so that ``CliRunner``,
+    # which patches it there during test isolation, is honored.
+    if _compat.should_strip_ansi(stream, resolve_color_default()):
+        text = strip_ansi(text)
+
+    if err:
+        with redirect_stdout(sys.stderr):
+            return func(text)
+    return func(text)
+
+
+def _build_prompt(
+    text: str,
+    suffix: str,
+    show_default: bool | str = False,
+    default: object | None = None,
+    show_choices: bool = True,
+    type: object | None = None,
+) -> str:
+    prompt = text
+    if type is not None and show_choices and isinstance(type, Choice):
+        prompt += f" ({', '.join(map(str, type.choices))})"
+    default_preview = ""
+    if show_default:
+        if isinstance(show_default, str):
+            default_preview = f" [({show_default})]"
+        elif default is not None:
+            default_preview = f" [{_format_default(default)}]"
+    return f"{prompt}{default_preview}{suffix}"
+
+
+def _format_default(default: V) -> V | str:
+    if isinstance(default, (io.IOBase, _LazyFile)):
+        name = getattr(default, "name", None)
+
+        if name is not None:
+            return str(name)
+
+    return default
+
+
+@t.overload
+def prompt(
+    text: str,
+    default: str | None = None,
+    hide_input: bool = False,
+    confirmation_prompt: bool | str = False,
+    type: None = None,
+    value_proc: None = None,
+    prompt_suffix: str = ": ",
+    show_default: bool | str = True,
+    err: bool = False,
+    show_choices: bool = True,
+) -> str: ...
+
+
+@t.overload
+def prompt(
+    text: str,
+    default: V | str | None = None,
+    hide_input: bool = False,
+    confirmation_prompt: bool | str = False,
+    type: ParamType[V, str] | type[V] | None = None,
+    value_proc: t.Callable[[str], V] | None = None,
+    prompt_suffix: str = ": ",
+    show_default: bool | str = True,
+    err: bool = False,
+    show_choices: bool = True,
+) -> V: ...
+
+
+def prompt(
+    text: str,
+    default: V | str | None = None,
+    hide_input: bool = False,
+    confirmation_prompt: bool | str = False,
+    type: ParamType[V, str] | type[V] | None = None,
+    value_proc: t.Callable[[str], V] | None = None,
+    prompt_suffix: str = ": ",
+    show_default: bool | str = True,
+    err: bool = False,
+    show_choices: bool = True,
+) -> V:
+    """Prompts a user for input.  This is a convenience function that can
+    be used to prompt a user for input later.
+
+    If the user aborts the input by sending an interrupt signal, this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the text to show for the prompt.
+    :param default: the default value to use if no input happens.  If this
+                    is not given it will prompt until it's aborted.
+    :param hide_input: if this is set to true then the input value will
+                       be hidden.
+    :param confirmation_prompt: Prompt a second time to confirm the
+        value. Can be set to a string instead of ``True`` to customize
+        the message.
+    :param type: the type to use to check the value against.
+    :param value_proc: if this parameter is provided it's a function that
+                       is invoked instead of the type conversion to
+                       convert a value.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+                         If this value is a string, it shows that string
+                         in parentheses instead of the actual value.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    :param show_choices: Show or hide choices if the passed type is a Choice.
+                         For example if type is a Choice of either day or week,
+                         show_choices is true and text is "Group by" then the
+                         prompt will be "Group by (day, week): ".
+
+    .. versionchanged:: 8.5.0
+        Generically typed: the return type is narrowed by ``type``,
+        ``value_proc``, or ``default`` instead of being ``Any``. Runtime
+        behavior is unchanged.
+
+    .. versionchanged:: 8.3.3
+        ``show_default`` can be a string to show a custom value instead
+        of the actual default, matching the help text behavior.
+
+    .. versionchanged:: 8.3.1
+        A space is no longer appended to the prompt.
+
+    .. versionadded:: 8.0
+        ``confirmation_prompt`` can be a custom string.
+
+    .. versionadded:: 7.0
+        Added the ``show_choices`` parameter.
+
+    .. versionadded:: 6.0
+        Added unicode support for cmd.exe on Windows.
+
+    .. versionadded:: 4.0
+        Added the `err` parameter.
+
+    """
+
+    def prompt_func(text: str) -> str:
+        f = hidden_prompt_func if hide_input else visible_prompt_func
+        try:
+            return _readline_prompt(f, text, err)
+        except (KeyboardInterrupt, EOFError):
+            # getpass doesn't print a newline if the user aborts input with ^C.
+            # Allegedly this behavior is inherited from getpass(3).
+            # A doc bug has been filed at https://bugs.python.org/issue24711
+            if hide_input:
+                echo(None, err=err)
+            raise Abort() from None
+
+    if value_proc is None:
+        value_proc = convert_type(type, default)
+
+    prompt = _build_prompt(
+        text, prompt_suffix, show_default, default, show_choices, type
+    )
+
+    if confirmation_prompt:
+        if confirmation_prompt is True:
+            confirmation_prompt = _("Repeat for confirmation")
+
+        confirmation_prompt = _build_prompt(confirmation_prompt, prompt_suffix)
+
+    while True:
+        while True:
+            value = prompt_func(prompt)
+            if value:
+                break
+            elif default is not None:
+                # Defaults of any type are accepted and round trip through
+                # value_proc like typed input, so the annotation is only
+                # accurate for typed input.
+                value = t.cast("str", default)
+                break
+        try:
+            result = value_proc(value)
+        except UsageError as e:
+            message = _mask_hidden_input(e.message, value) if hide_input else e.message
+            echo(_("Error: {message}").format(message=message), err=err)
+            continue
+        if not confirmation_prompt:
+            return result
+        while True:
+            value2 = prompt_func(confirmation_prompt)
+            is_empty = not value and not value2
+            if value2 or is_empty:
+                break
+        if value == value2:
+            return result
+        echo(_("Error: The two entered values do not match."), err=err)
+
+
+def confirm(
+    text: str,
+    default: bool | None = False,
+    abort: bool = False,
+    prompt_suffix: str = ": ",
+    show_default: bool = True,
+    err: bool = False,
+) -> bool:
+    """Prompts for confirmation (yes/no question).
+
+    If the user aborts the input by sending a interrupt signal this
+    function will catch it and raise a :exc:`Abort` exception.
+
+    :param text: the question to ask.
+    :param default: The default value to use when no input is given. If
+        ``None``, repeat until input is given.
+    :param abort: if this is set to `True` a negative answer aborts the
+                  exception by raising :exc:`Abort`.
+    :param prompt_suffix: a suffix that should be added to the prompt.
+    :param show_default: shows or hides the default value in the prompt.
+    :param err: if set to true the file defaults to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+
+    .. versionchanged:: 8.3.1
+        A space is no longer appended to the prompt.
+
+    .. versionchanged:: 8.0
+        Repeat until input is given if ``default`` is ``None``.
+
+    .. versionadded:: 4.0
+        Added the ``err`` parameter.
+    """
+    prompt = _build_prompt(
+        text,
+        prompt_suffix,
+        show_default,
+        "y/n" if default is None else ("Y/n" if default else "y/N"),
+    )
+
+    while True:
+        try:
+            value = _readline_prompt(visible_prompt_func, prompt, err).lower().strip()
+        except (KeyboardInterrupt, EOFError):
+            raise Abort() from None
+        if value in ("y", "yes"):
+            rv = True
+        elif value in ("n", "no"):
+            rv = False
+        elif default is not None and value == "":
+            rv = default
+        else:
+            echo(_("Error: invalid input"), err=err)
+            continue
+        break
+    if abort and not rv:
+        raise Abort()
+    return rv
+
+
+def get_pager_file(
+    color: bool | None = None,
+) -> t.ContextManager[t.TextIO]:
+    """Context manager.
+
+    Yields a writable file-like object which can be used as an output pager.
+
+    .. versionadded:: 8.4.0
+
+    :param color: controls if the pager supports ANSI colors or not.  The
+                  default is autodetection.
+    """
+    from ._termui_impl import get_pager_file
+
+    color = resolve_color_default(color)
+
+    return get_pager_file(color=color)
+
+
+def echo_via_pager(
+    text_or_generator: cabc.Iterable[str] | t.Callable[[], cabc.Iterable[str]] | str,
+    color: bool | None = None,
+) -> None:
+    """This function takes a text and shows it via an environment specific
+    pager on stdout.
+
+    .. versionchanged:: 3.0
+       Added the `color` flag.
+
+    :param text_or_generator: the text to page, or alternatively, a
+                              generator emitting the text to page.
+    :param color: controls if the pager supports ANSI colors or not.  The
+                  default is autodetection.
+    """
+
+    if inspect.isgeneratorfunction(text_or_generator):
+        i = t.cast("t.Callable[[], cabc.Iterable[str]]", text_or_generator)()
+    elif isinstance(text_or_generator, str):
+        i = [text_or_generator]
+    else:
+        i = iter(t.cast("cabc.Iterable[str]", text_or_generator))
+
+    # convert every element of i to a text type if necessary
+    text_generator = (el if isinstance(el, str) else str(el) for el in i)
+
+    with get_pager_file(color=color) as pager:
+        for text in itertools.chain(text_generator, "\n"):
+            pager.write(text)
+            # Flush after each write so a slow generator streams to the pager
+            # incrementally rather than staying invisible until the pipe buffer
+            # fills (~8 KB).
+            pager.flush()
+
+
+@t.overload
+def progressbar(
+    *,
+    length: int,
+    label: str | None = None,
+    hidden: bool = False,
+    show_eta: bool = True,
+    show_percent: bool | None = None,
+    show_pos: bool = False,
+    fill_char: str = "#",
+    empty_char: str = "-",
+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
+    info_sep: str = "  ",
+    width: int = 36,
+    file: t.TextIO | None = None,
+    color: bool | None = None,
+    update_min_steps: int = 1,
+) -> ProgressBar[int]: ...
+
+
+@t.overload
+def progressbar(
+    iterable: cabc.Iterable[V] | None = None,
+    length: int | None = None,
+    label: str | None = None,
+    hidden: bool = False,
+    show_eta: bool = True,
+    show_percent: bool | None = None,
+    show_pos: bool = False,
+    item_show_func: t.Callable[[V | None], str | None] | None = None,
+    fill_char: str = "#",
+    empty_char: str = "-",
+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
+    info_sep: str = "  ",
+    width: int = 36,
+    file: t.TextIO | None = None,
+    color: bool | None = None,
+    update_min_steps: int = 1,
+) -> ProgressBar[V]: ...
+
+
+def progressbar(
+    iterable: cabc.Iterable[V] | None = None,
+    length: int | None = None,
+    label: str | None = None,
+    hidden: bool = False,
+    show_eta: bool = True,
+    show_percent: bool | None = None,
+    show_pos: bool = False,
+    item_show_func: t.Callable[[V | None], str | None] | None = None,
+    fill_char: str = "#",
+    empty_char: str = "-",
+    bar_template: str = "%(label)s  [%(bar)s]  %(info)s",
+    info_sep: str = "  ",
+    width: int = 36,
+    file: t.TextIO | None = None,
+    color: bool | None = None,
+    update_min_steps: int = 1,
+) -> ProgressBar[V]:
+    """This function creates an iterable context manager that can be used
+    to iterate over something while showing a progress bar.  It will
+    either iterate over the `iterable` or `length` items (that are counted
+    up).  While iteration happens, this function will print a rendered
+    progress bar to the given `file` (defaults to stdout) and will attempt
+    to calculate remaining time and more.  By default, this progress bar
+    will not be rendered if the file is not a terminal.
+
+    The context manager creates the progress bar.  When the context
+    manager is entered the progress bar is already created.  With every
+    iteration over the progress bar, the iterable passed to the bar is
+    advanced and the bar is updated.  When the context manager exits,
+    a newline is printed and the progress bar is finalized on screen.
+
+    Note: The progress bar is currently designed for use cases where the
+    total progress can be expected to take at least several seconds.
+    Because of this, the ProgressBar class object won't display
+    progress that is considered too fast, and progress where the time
+    between steps is less than a second.
+
+    No printing must happen or the progress bar will be unintentionally
+    destroyed.
+
+    Example usage::
+
+        with progressbar(items) as bar:
+            for item in bar:
+                do_something_with(item)
+
+    Alternatively, if no iterable is specified, one can manually update the
+    progress bar through the `update()` method instead of directly
+    iterating over the progress bar.  The update method accepts the number
+    of steps to increment the bar with::
+
+        with progressbar(length=chunks.total_bytes) as bar:
+            for chunk in chunks:
+                process_chunk(chunk)
+                bar.update(chunks.bytes)
+
+    The ``update()`` method also takes an optional value specifying the
+    ``current_item`` at the new position. This is useful when used
+    together with ``item_show_func`` to customize the output for each
+    manual step::
+
+        with click.progressbar(
+            length=total_size,
+            label='Unzipping archive',
+            item_show_func=lambda a: a.filename
+        ) as bar:
+            for archive in zip_file:
+                archive.extract()
+                bar.update(archive.size, archive)
+
+    :param iterable: an iterable to iterate over.  If not provided the length
+                     is required.
+    :param length: the number of items to iterate over.  By default the
+                   progressbar will attempt to ask the iterator about its
+                   length, which might or might not work.  If an iterable is
+                   also provided this parameter can be used to override the
+                   length.  If an iterable is not provided the progress bar
+                   will iterate over a range of that length.
+    :param label: the label to show next to the progress bar.
+    :param hidden: hide the progressbar. Defaults to ``False``. When no tty is
+        detected, it will only print the progressbar label. Setting this to
+        ``False`` also disables that.
+    :param show_eta: enables or disables the estimated time display.  This is
+                     automatically disabled if the length cannot be
+                     determined.
+    :param show_percent: enables or disables the percentage display.  The
+                         default is `True` if the iterable has a length or
+                         `False` if not.
+    :param show_pos: enables or disables the absolute position display.  The
+                     default is `False`.
+    :param item_show_func: A function called with the current item which
+        can return a string to show next to the progress bar. If the
+        function returns ``None`` nothing is shown. The current item can
+        be ``None``, such as when entering and exiting the bar.
+    :param fill_char: the character to use to show the filled part of the
+                      progress bar.
+    :param empty_char: the character to use to show the non-filled part of
+                       the progress bar.
+    :param bar_template: the format string to use as template for the bar.
+                         The parameters in it are ``label`` for the label,
+                         ``bar`` for the progress bar and ``info`` for the
+                         info section.
+    :param info_sep: the separator between multiple info items (eta etc.)
+    :param width: the width of the progress bar in characters, 0 means full
+                  terminal width
+    :param file: The file to write to. If this is not a terminal then
+        only the label is printed.
+    :param color: controls if the terminal supports ANSI colors or not.  The
+                  default is autodetection.  This is only needed if ANSI
+                  codes are included anywhere in the progress bar output
+                  which is not the case by default.
+    :param update_min_steps: Render only when this many updates have
+        completed. This allows tuning for very fast iterators.
+
+    .. versionadded:: 8.2
+        The ``hidden`` argument.
+
+    .. versionchanged:: 8.0
+        Output is shown even if execution time is less than 0.5 seconds.
+
+    .. versionchanged:: 8.0
+        ``item_show_func`` shows the current item, not the previous one.
+
+    .. versionchanged:: 8.0
+        Labels are echoed if the output is not a TTY. Reverts a change
+        in 7.0 that removed all output.
+
+    .. versionadded:: 8.0
+       The ``update_min_steps`` parameter.
+
+    .. versionadded:: 4.0
+        The ``color`` parameter and ``update`` method.
+
+    .. versionadded:: 2.0
+    """
+    from ._termui_impl import ProgressBar
+
+    color = resolve_color_default(color)
+    return ProgressBar(
+        iterable=iterable,
+        length=length,
+        hidden=hidden,
+        show_eta=show_eta,
+        show_percent=show_percent,
+        show_pos=show_pos,
+        item_show_func=item_show_func,
+        fill_char=fill_char,
+        empty_char=empty_char,
+        bar_template=bar_template,
+        info_sep=info_sep,
+        file=file,
+        label=label,
+        width=width,
+        color=color,
+        update_min_steps=update_min_steps,
+    )
+
+
+def clear() -> None:
+    """Clears the terminal screen.  This will have the effect of clearing
+    the whole visible space of the terminal and moving the cursor to the
+    top left.  This does not do anything if not connected to a terminal.
+
+    .. versionadded:: 2.0
+    """
+    if not isatty(sys.stdout):
+        return
+
+    # ANSI escape \033[2J clears the screen, \033[1;1H moves the cursor
+    echo("\033[2J\033[1;1H", nl=False)
+
+
+def _interpret_color(color: int | tuple[int, int, int] | str, offset: int = 0) -> str:
+    """Interprets a color value and returns the corresponding ANSI code."""
+    if isinstance(color, str) and color in _ansi_colors:
+        return str(_ansi_colors[color] + offset)
+
+    # bool is an int subclass: without the exclusion, True and False would
+    # silently render as the palette indices 1 and 0.
+    elif isinstance(color, int) and not isinstance(color, bool):
+        if 0 <= color <= 255:
+            return f"{38 + offset};5;{color:d}"
+
+    elif (
+        isinstance(color, (tuple, list))
+        and len(color) == 3
+        and all(
+            isinstance(c, int) and not isinstance(c, bool) and 0 <= c <= 255
+            for c in color
+        )
+    ):
+        r, g, b = color
+        return f"{38 + offset};2;{r:d};{g:d};{b:d}"
+
+    raise ValueError(_("Unknown color {colour!r}").format(colour=color))
+
+
+def style(
+    text: t.Any,
+    fg: int | tuple[int, int, int] | str | None = None,
+    bg: int | tuple[int, int, int] | str | None = None,
+    bold: bool | None = None,
+    dim: bool | None = None,
+    underline: bool | None = None,
+    overline: bool | None = None,
+    italic: bool | None = None,
+    blink: bool | None = None,
+    reverse: bool | None = None,
+    strikethrough: bool | None = None,
+    reset: bool = True,
+) -> str:
+    """Styles a text with ANSI styles and returns the new string.  By
+    default the styling is self contained which means that at the end
+    of the string a reset code is issued.  This can be prevented by
+    passing ``reset=False``.
+
+    Examples::
+
+        click.echo(click.style('Hello World!', fg='green'))
+        click.echo(click.style('ATTENTION!', blink=True))
+        click.echo(click.style('Some things', reverse=True, fg='cyan'))
+        click.echo(click.style('More colors', fg=(255, 12, 128), bg=117))
+
+    Supported color names:
+
+    * ``black`` (might be a gray)
+    * ``red``
+    * ``green``
+    * ``yellow`` (might be an orange)
+    * ``blue``
+    * ``magenta``
+    * ``cyan``
+    * ``white`` (might be light gray)
+    * ``bright_black``
+    * ``bright_red``
+    * ``bright_green``
+    * ``bright_yellow``
+    * ``bright_blue``
+    * ``bright_magenta``
+    * ``bright_cyan``
+    * ``bright_white``
+    * ``reset`` (reset the color code only)
+
+    If the terminal supports it, color may also be specified as:
+
+    -   An integer in the interval [0, 255]. The terminal must support
+        8-bit/256-color mode.
+    -   An RGB tuple of three integers in [0, 255]. The terminal must
+        support 24-bit/true-color mode.
+
+    See https://en.wikipedia.org/wiki/ANSI_color and
+    https://gist.github.com/XVilka/8346728 for more information.
+
+    :param text: the string to style with ansi codes.
+    :param fg: if provided this will become the foreground color.
+    :param bg: if provided this will become the background color.
+    :param bold: if provided this will enable or disable bold mode.
+    :param dim: if provided this will enable or disable dim mode.  This is
+                badly supported.
+    :param underline: if provided this will enable or disable underline.
+    :param overline: if provided this will enable or disable overline.
+    :param italic: if provided this will enable or disable italic.
+    :param blink: if provided this will enable or disable blinking.
+    :param reverse: if provided this will enable or disable inverse
+                    rendering (foreground becomes background and the
+                    other way round).
+    :param strikethrough: if provided this will enable or disable
+        striking through text.
+    :param reset: by default a reset-all code is added at the end of the
+                  string which means that styles do not carry over.  This
+                  can be disabled to compose styles.
+
+    .. versionchanged:: 8.5.0
+        All invalid color values raise :exc:`ValueError`. 256-color index
+        ``0`` is no longer ignored.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string.
+
+    .. versionchanged:: 8.0
+       Added support for 256 and RGB color codes.
+
+    .. versionchanged:: 8.0
+        Added the ``strikethrough``, ``italic``, and ``overline``
+        parameters.
+
+    .. versionchanged:: 7.0
+        Added support for bright colors.
+
+    .. versionadded:: 2.0
+    """
+    if not isinstance(text, str):
+        text = str(text)
+
+    bits = []
+
+    if fg is not None:
+        bits.append(f"\033[{_interpret_color(fg)}m")
+
+    if bg is not None:
+        bits.append(f"\033[{_interpret_color(bg, 10)}m")
+
+    if bold is not None:
+        bits.append(f"\033[{1 if bold else 22}m")
+    if dim is not None:
+        bits.append(f"\033[{2 if dim else 22}m")
+    if underline is not None:
+        bits.append(f"\033[{4 if underline else 24}m")
+    if overline is not None:
+        bits.append(f"\033[{53 if overline else 55}m")
+    if italic is not None:
+        bits.append(f"\033[{3 if italic else 23}m")
+    if blink is not None:
+        bits.append(f"\033[{5 if blink else 25}m")
+    if reverse is not None:
+        bits.append(f"\033[{7 if reverse else 27}m")
+    if strikethrough is not None:
+        bits.append(f"\033[{9 if strikethrough else 29}m")
+    bits.append(text)
+    if reset:
+        bits.append(_ansi_reset_all)
+    return "".join(bits)
+
+
+def unstyle(text: str) -> str:
+    """Removes ANSI styling information from a string.  Usually it's not
+    necessary to use this function as Click's echo function will
+    automatically remove styling if necessary.
+
+    .. versionadded:: 2.0
+
+    :param text: the text to remove style information from.
+    """
+    return strip_ansi(text)
+
+
+def secho(
+    message: t.Any | None = None,
+    file: t.IO[t.AnyStr] | None = None,
+    nl: bool = True,
+    err: bool = False,
+    color: bool | None = None,
+    **styles: t.Any,
+) -> None:
+    """This function combines :func:`echo` and :func:`style` into one
+    call.  As such the following two calls are the same::
+
+        click.secho('Hello World!', fg='green')
+        click.echo(click.style('Hello World!', fg='green'))
+
+    All keyword arguments are forwarded to the underlying functions
+    depending on which one they go with.
+
+    Non-string types will be converted to :class:`str`. However,
+    :class:`bytes` are passed directly to :meth:`echo` without applying
+    style. If you want to style bytes that represent text, call
+    :meth:`bytes.decode` first.
+
+    .. versionchanged:: 8.0
+        A non-string ``message`` is converted to a string. Bytes are
+        passed through without style applied.
+
+    .. versionadded:: 2.0
+    """
+    if message is not None and not isinstance(message, (bytes, bytearray)):
+        message = style(message, **styles)
+
+    return echo(message, file=file, nl=nl, err=err, color=color)
+
+
+@t.overload
+def edit(
+    text: bytes | bytearray,
+    editor: str | None = None,
+    env: cabc.Mapping[str, str] | None = None,
+    require_save: bool = False,
+    extension: str = ".txt",
+) -> bytes | None: ...
+
+
+@t.overload
+def edit(
+    text: str,
+    editor: str | None = None,
+    env: cabc.Mapping[str, str] | None = None,
+    require_save: bool = True,
+    extension: str = ".txt",
+) -> str | None: ...
+
+
+@t.overload
+def edit(
+    text: None = None,
+    editor: str | None = None,
+    env: cabc.Mapping[str, str] | None = None,
+    require_save: bool = True,
+    extension: str = ".txt",
+    filename: str
+    | os.PathLike[str]
+    | cabc.Iterable[str | os.PathLike[str]]
+    | None = None,
+) -> None: ...
+
+
+def edit(
+    text: str | bytes | bytearray | None = None,
+    editor: str | None = None,
+    env: cabc.Mapping[str, str] | None = None,
+    require_save: bool = True,
+    extension: str = ".txt",
+    filename: str
+    | os.PathLike[str]
+    | cabc.Iterable[str | os.PathLike[str]]
+    | None = None,
+) -> str | bytes | bytearray | None:
+    r"""Edits the given text in the defined editor.  If an editor is given
+    (should be the full path to the executable but the regular operating
+    system search path is used for finding the executable) it overrides
+    the detected editor.  Optionally, some environment variables can be
+    used.  If the editor is closed without changes, `None` is returned.  In
+    case a file is edited directly the return value is always `None` and
+    `require_save` and `extension` are ignored.
+
+    If the editor cannot be opened a :exc:`UsageError` is raised.
+
+    Note for Windows: to simplify cross-platform usage, the newlines are
+    automatically converted from POSIX to Windows and vice versa.  As such,
+    the message here will have ``\n`` as newline markers.
+
+    :param text: the text to edit.
+    :param editor: optionally the editor to use.  Defaults to automatic
+                   detection.
+    :param env: environment variables to forward to the editor.
+    :param require_save: if this is true, then not saving in the editor
+                         will make the return value become `None`.
+    :param extension: the extension to tell the editor about.  This defaults
+                      to `.txt` but changing this might change syntax
+                      highlighting.
+    :param filename: if provided it will edit this file instead of the
+                     provided text contents.  It will not use a temporary
+                     file as an indirection in that case. It accepts a path
+                     or any iterable of paths. If the editor supports
+                     editing multiple files at once, a sequence of files may
+                     be passed as well. Invoke `click.file` once per file
+                     instead if multiple files cannot be managed at once or
+                     editing the files serially is desired.
+
+    .. versionchanged:: 8.2.0
+        ``filename`` now accepts any ``Iterable[str]`` in addition to a ``str``
+        if the ``editor`` supports editing multiple files at once.
+
+    .. versionchanged:: 8.5.0
+        ``filename`` accepts ``os.PathLike`` values in addition to strings.
+
+    """
+    from ._termui_impl import Editor
+
+    ed = Editor(editor=editor, env=env, require_save=require_save, extension=extension)
+
+    if filename is None:
+        return ed.edit(text)
+
+    if isinstance(filename, (str, os.PathLike)):
+        filename = (filename,)
+
+    ed.edit_files(filenames=filename)
+    return None
+
+
+def launch(url: str, wait: bool = False, locate: bool = False) -> int:
+    """This function launches the given URL (or filename) in the default
+    viewer application for this file type.  If this is an executable, it
+    might launch the executable in a new session.  The return value is
+    the exit code of the launched application.  Usually, ``0`` indicates
+    success.
+
+    Examples::
+
+        click.launch('https://click.palletsprojects.com/')
+        click.launch('/my/downloaded/file', locate=True)
+
+    .. versionadded:: 2.0
+
+    :param url: URL or filename of the thing to launch.
+    :param wait: Wait for the program to exit before returning. This
+        only works if the launched program blocks. In particular,
+        ``xdg-open`` on Linux does not block.
+    :param locate: if this is set to `True` then instead of launching the
+                   application associated with the URL it will attempt to
+                   launch a file manager with the file located.  This
+                   might have weird effects if the URL does not point to
+                   the filesystem.
+    """
+    from ._termui_impl import open_url
+
+    return open_url(url, wait=wait, locate=locate)
+
+
+# If this is provided, getchar() calls into this instead.  This is used
+# for unittesting purposes.
+_getchar: t.Callable[[bool], str] | None = None
+
+
+def getchar(echo: bool = False) -> str:
+    """Fetches a single character from the terminal and returns it.  This
+    will always return a unicode character and under certain rare
+    circumstances this might return more than one character.  The
+    situations which more than one character is returned is when for
+    whatever reason multiple characters end up in the terminal buffer or
+    standard input was not actually a terminal.
+
+    Note that this will always read from the terminal, even if something
+    is piped into the standard input.
+
+    Note for Windows: in rare cases when typing non-ASCII characters, this
+    function might wait for a second character and then return both at once.
+    This is because certain Unicode characters look like special-key markers.
+
+    .. versionadded:: 2.0
+
+    :param echo: if set to `True`, the character read will also show up on
+                 the terminal.  The default is to not show it.
+    """
+    global _getchar
+
+    if _getchar is None:
+        from ._termui_impl import getchar as f
+
+        _getchar = f
+
+    return _getchar(echo)
+
+
+def raw_terminal() -> AbstractContextManager[int]:
+    from ._termui_impl import raw_terminal as f
+
+    return f()
+
+
+def pause(info: str | None = None, err: bool = False) -> None:
+    """This command stops execution and waits for the user to press any
+    key to continue.  This is similar to the Windows batch "pause"
+    command.  If the program is not run through a terminal, this command
+    will instead do nothing.
+
+    .. versionadded:: 2.0
+
+    .. versionadded:: 4.0
+       Added the `err` parameter.
+
+    :param info: The message to print before pausing. Defaults to
+        ``"Press any key to continue..."``.
+    :param err: if set to message goes to ``stderr`` instead of
+                ``stdout``, the same as with echo.
+    """
+    if not isatty(sys.stdin) or not isatty(sys.stdout):
+        return
+
+    if info is None:
+        info = _("Press any key to continue...")
+
+    try:
+        if info:
+            echo(info, nl=False, err=err)
+        try:
+            getchar()
+        except (KeyboardInterrupt, EOFError):
+            pass
+    finally:
+        if info:
+            echo(err=err)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/testing.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/testing.py
new file mode 100644
index 0000000000000000000000000000000000000000..cc123d4d15fda16262db16cefc467b1fffd9ac5d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/testing.py
@@ -0,0 +1,798 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import contextlib
+import io
+import os
+import pdb
+import shlex
+import sys
+import tempfile
+import typing as t
+from types import TracebackType
+
+from . import _compat
+from . import formatting
+from . import termui
+from . import utils
+from ._compat import _find_binary_reader
+
+if t.TYPE_CHECKING:
+    from _typeshed import ReadableBuffer
+
+    from .core import Command
+
+if sys.platform == "win32":
+    CaptureMode: t.TypeAlias = t.Literal["sys"]  # pyright: ignore[reportRedeclaration]
+else:
+    CaptureMode: t.TypeAlias = t.Literal["sys", "fd"]  # pyright: ignore[reportRedeclaration]
+ExceptionInfo: t.TypeAlias = tuple[type[BaseException], BaseException, TracebackType]
+
+
+class EchoingStdin:
+    _input: t.BinaryIO
+    _output: t.BinaryIO
+    _paused: bool
+
+    def __init__(self, input: t.BinaryIO, output: t.BinaryIO) -> None:
+        self._input = input
+        self._output = output
+        self._paused = False
+
+    def __getattr__(self, x: str) -> t.Any:
+        return getattr(self._input, x)
+
+    def _echo(self, rv: bytes) -> bytes:
+        if not self._paused:
+            self._output.write(rv)
+
+        return rv
+
+    def read(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read(n))
+
+    def read1(self, n: int = -1) -> bytes:
+        return self._echo(self._input.read1(n))  # type: ignore
+
+    def readline(self, n: int = -1) -> bytes:
+        return self._echo(self._input.readline(n))
+
+    def readlines(self) -> list[bytes]:
+        return [self._echo(x) for x in self._input.readlines()]
+
+    def __iter__(self) -> cabc.Iterator[bytes]:
+        return iter(self._echo(x) for x in self._input)
+
+    def __repr__(self) -> str:
+        return repr(self._input)
+
+
+@contextlib.contextmanager
+def _pause_echo(stream: EchoingStdin | None) -> cabc.Generator[None]:
+    if stream is None:
+        yield
+    else:
+        stream._paused = True
+        yield
+        stream._paused = False
+
+
+class _FDCapture:
+    """Redirect a file descriptor to a temporary file for capture.
+
+    Saves the current target of *targetfd* via :func:`os.dup`, then
+    redirects it to a temporary file via :func:`os.dup2`. On
+    :meth:`stop`, restores the original ``fd`` and returns the captured
+    bytes. Inspired by Pytest's ``FDCapture``.
+
+    .. versionadded:: 8.4.0
+    """
+
+    _targetfd: int
+    saved_fd: int
+    _tmpfile: t.BinaryIO | None
+
+    def __init__(self, targetfd: int) -> None:
+        self._targetfd = targetfd
+        self.saved_fd = -1
+        self._tmpfile = None
+
+    def start(self) -> None:
+        self.saved_fd = os.dup(self._targetfd)
+        self._tmpfile = tempfile.TemporaryFile(buffering=0)
+        os.dup2(self._tmpfile.fileno(), self._targetfd)
+
+    def stop(self) -> bytes:
+        assert self._tmpfile is not None, "_FDCapture.start() was not called"
+        os.dup2(self.saved_fd, self._targetfd)
+        os.close(self.saved_fd)
+        self.saved_fd = -1
+        self._tmpfile.seek(0)
+        data = self._tmpfile.read()
+        self._tmpfile.close()
+        self._tmpfile = None
+        return data
+
+
+class BytesIOCopy(io.BytesIO):
+    """Patch ``io.BytesIO`` to let the written stream be copied to another.
+
+    .. versionadded:: 8.2
+    """
+
+    copy_to: io.BytesIO
+
+    def __init__(self, copy_to: io.BytesIO) -> None:
+        super().__init__()
+        self.copy_to = copy_to
+
+    def flush(self) -> None:
+        super().flush()
+        self.copy_to.flush()
+
+    def write(self, b: ReadableBuffer) -> int:
+        self.copy_to.write(b)
+        return super().write(b)
+
+
+class StreamMixer:
+    """Mixes `<stdout>` and `<stderr>` streams.
+
+    The result is available in the ``output`` attribute.
+
+    .. versionadded:: 8.2
+    """
+
+    output: io.BytesIO
+    stdout: BytesIOCopy
+    stderr: BytesIOCopy
+
+    def __init__(self) -> None:
+        self.output = io.BytesIO()
+        self.stdout = BytesIOCopy(copy_to=self.output)
+        self.stderr = BytesIOCopy(copy_to=self.output)
+
+
+class _NamedTextIOWrapper(io.TextIOWrapper):
+    """A :class:`~io.TextIOWrapper` with custom ``name`` and ``mode``
+    that does not close its underlying buffer.
+
+    When ``CliRunner`` runs in ``fd`` mode, ``_original_fd`` is patched to
+    point at the saved (pre-redirection) ``fd``, so C-level consumers that call
+    :meth:`fileno` (like ``faulthandler`` or ``subprocess``) keep working. In
+    the default ``sys`` mode ``_original_fd`` stays at ``-1`` and
+    :meth:`fileno` raises :exc:`io.UnsupportedOperation`, matching the
+    pre-``8.3.3`` behavior.
+    """
+
+    _name: str
+    _mode: str
+    _original_fd: int
+
+    def __init__(
+        self,
+        buffer: t.BinaryIO,
+        name: str,
+        mode: str,
+        **kwargs: t.Any,
+    ) -> None:
+        super().__init__(buffer, **kwargs)
+        self._name = name
+        self._mode = mode
+        self._original_fd = -1
+
+    def close(self) -> None:
+        """The buffer this object contains belongs to some other object,
+        so prevent the default ``__del__`` implementation from closing
+        that buffer.
+
+        .. versionadded:: 8.3.2
+        """
+
+    def fileno(self) -> int:
+        """Return the file descriptor of the saved original stream when
+        ``CliRunner`` runs in ``fd`` mode. Otherwise delegate to
+        :class:`~io.TextIOWrapper`, which raises
+        :exc:`io.UnsupportedOperation` for a ``BytesIO``-backed buffer.
+        """
+        if self._original_fd >= 0:
+            return self._original_fd
+        return super().fileno()
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def mode(self) -> str:
+        return self._mode
+
+
+def make_input_stream(
+    input: str | bytes | t.IO[t.Any] | None, charset: str
+) -> t.BinaryIO:
+    # Is already an input stream.
+    if hasattr(input, "read"):
+        rv = _find_binary_reader(t.cast("t.IO[t.Any]", input))
+
+        if rv is not None:
+            return rv
+
+        raise TypeError("Could not find binary reader for input stream.")
+
+    if input is None:
+        input = b""
+    elif isinstance(input, str):
+        input = input.encode(charset)
+
+    return io.BytesIO(input)
+
+
+class Result:
+    """Holds the captured result of an invoked CLI script.
+
+    :param runner: The runner that created the result
+    :param stdout_bytes: The standard output as bytes.
+    :param stderr_bytes: The standard error as bytes.
+    :param output_bytes: A mix of ``stdout_bytes`` and ``stderr_bytes``, as the
+        user would see  it in its terminal.
+    :param return_value: The value returned from the invoked command.
+    :param exit_code: The exit code as integer.
+    :param exception: The exception that happened if one did.
+    :param exc_info: Exception information (exception type, exception instance,
+        traceback type).
+
+    .. versionchanged:: 8.2
+        ``stderr_bytes`` no longer optional, ``output_bytes`` introduced and
+        ``mix_stderr`` has been removed.
+
+    .. versionadded:: 8.0
+        Added ``return_value``.
+    """
+
+    runner: CliRunner
+    stdout_bytes: bytes
+    stderr_bytes: bytes
+    output_bytes: bytes
+    return_value: t.Any
+    exit_code: int
+    exception: BaseException | None
+    exc_info: ExceptionInfo | None
+
+    def __init__(
+        self,
+        runner: CliRunner,
+        stdout_bytes: bytes,
+        stderr_bytes: bytes,
+        output_bytes: bytes,
+        return_value: t.Any,
+        exit_code: int,
+        exception: BaseException | None,
+        exc_info: ExceptionInfo | None = None,
+    ) -> None:
+        self.runner = runner
+        self.stdout_bytes = stdout_bytes
+        self.stderr_bytes = stderr_bytes
+        self.output_bytes = output_bytes
+        self.return_value = return_value
+        self.exit_code = exit_code
+        self.exception = exception
+        self.exc_info = exc_info
+
+    @property
+    def output(self) -> str:
+        """The terminal output as unicode string, as the user would see it.
+
+        .. versionchanged:: 8.2
+            No longer a proxy for ``self.stdout``. Now has its own independent stream
+            that is mixing `<stdout>` and `<stderr>`, in the order they were written.
+        """
+        return self.output_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stdout(self) -> str:
+        """The standard output as unicode string."""
+        return self.stdout_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    @property
+    def stderr(self) -> str:
+        """The standard error as unicode string.
+
+        .. versionchanged:: 8.2
+            No longer raise an exception, always returns the `<stderr>` string.
+        """
+        return self.stderr_bytes.decode(self.runner.charset, "replace").replace(
+            "\r\n", "\n"
+        )
+
+    def __repr__(self) -> str:
+        exc_str = repr(self.exception) if self.exception else "okay"
+        return f"<{type(self).__name__} {exc_str}>"
+
+
+class CliRunner:
+    """The CLI runner provides functionality to invoke a Click command line
+    script for unittesting purposes in a isolated environment.  This only
+    works in single-threaded systems without any concurrency as it changes the
+    global interpreter state.
+
+    :param charset: the character set for the input and output data.
+    :param env: a dictionary with environment variables for overriding.
+    :param echo_stdin: if this is set to `True`, then reading from `<stdin>` writes
+                       to `<stdout>`.  This is useful for showing examples in
+                       some circumstances.  Note that regular prompts
+                       will automatically echo the input.
+    :param catch_exceptions: Whether to catch any exceptions other than
+                             ``SystemExit`` when running :meth:`~CliRunner.invoke`.
+    :param capture: Selects the output capture strategy. ``sys`` (default)
+        captures Python-level writes only and leaves
+        :meth:`sys.stdout.fileno` raising :exc:`io.UnsupportedOperation`, so
+        user code that calls :func:`os.dup2` on ``sys.stdout.fileno()`` cannot
+        clobber the host runner's stdout. ``fd`` redirects file descriptors
+        ``1`` and ``2`` via :func:`os.dup2` to a temporary file, also catching
+        output from stale stream references, C extensions, and subprocesses.
+        ``fd`` is not supported on Windows.
+
+    .. versionchanged:: 8.4.0
+        Added the ``capture`` parameter. The default ``sys`` mode no longer
+        exposes the original fd through :meth:`fileno`, reverting the change
+        introduced in ``8.3.3`` that broke Pytest's ``fd``-level capture
+        teardown. Use ``capture="fd"`` to restore that behavior with proper
+        isolation. :issue:`3384`
+
+    .. versionchanged:: 8.2
+        Added the ``catch_exceptions`` parameter.
+
+    .. versionchanged:: 8.2
+        ``mix_stderr`` parameter has been removed.
+    """
+
+    charset: str
+    env: cabc.Mapping[str, str | None]
+    echo_stdin: bool
+    catch_exceptions: bool
+    capture: CaptureMode
+
+    def __init__(
+        self,
+        charset: str = "utf-8",
+        env: cabc.Mapping[str, str | None] | None = None,
+        echo_stdin: bool = False,
+        catch_exceptions: bool = True,
+        capture: CaptureMode = "sys",
+    ) -> None:
+        if capture not in {"sys", "fd"}:
+            raise ValueError(
+                f"capture={capture!r} is not valid. Choose from 'sys' or 'fd'."
+            )
+        if capture == "fd" and sys.platform == "win32":
+            raise ValueError(
+                f"capture={capture!r} is not supported on Windows. Use 'sys'."
+            )
+        self.charset = charset
+        self.env = env or {}
+        self.echo_stdin = echo_stdin
+        self.catch_exceptions = catch_exceptions
+        self.capture = capture
+
+    def get_default_prog_name(self, cli: Command) -> str:
+        """Given a command object it will return the default program name
+        for it.  The default is the `name` attribute or ``"root"`` if not
+        set.
+        """
+        return cli.name or "root"
+
+    def make_env(
+        self, overrides: cabc.Mapping[str, str | None] | None = None
+    ) -> cabc.Mapping[str, str | None]:
+        """Returns the environment overrides for invoking a script."""
+        rv = dict(self.env)
+        if overrides:
+            rv.update(overrides)
+        return rv
+
+    @contextlib.contextmanager
+    def isolation(
+        self,
+        input: str | bytes | t.IO[t.Any] | None = None,
+        env: cabc.Mapping[str, str | None] | None = None,
+        color: bool = False,
+    ) -> cabc.Generator[tuple[io.BytesIO, io.BytesIO, io.BytesIO]]:
+        """A context manager that sets up the isolation for invoking of a
+        command line tool.  This sets up `<stdin>` with the given input data
+        and `os.environ` with the overrides from the given dictionary.
+        This also rebinds some internals in Click to be mocked (like the
+        prompt functionality).
+
+        This is automatically done in the :meth:`invoke` method.
+
+        :param input: the input stream to put into `sys.stdin`.
+        :param env: the environment overrides as dictionary.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionadded:: 8.2
+            An additional output stream is returned, which is a mix of
+            `<stdout>` and `<stderr>` streams.
+
+        .. versionchanged:: 8.2
+            Always returns the `<stderr>` stream.
+
+        .. versionchanged:: 8.0
+            `<stderr>` is opened with ``errors="backslashreplace"``
+            instead of the default ``"strict"``.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+        """
+        bytes_input = make_input_stream(input, self.charset)
+        echo_input = None
+
+        old_stdin = sys.stdin
+        old_stdout = sys.stdout
+        old_stderr = sys.stderr
+        old_forced_width = formatting.FORCED_WIDTH
+        formatting.FORCED_WIDTH = 80
+
+        env = self.make_env(env)
+
+        stream_mixer = StreamMixer()
+
+        if self.echo_stdin:
+            bytes_input = echo_input = t.cast(
+                t.BinaryIO, EchoingStdin(bytes_input, stream_mixer.stdout)
+            )
+
+        sys.stdin = text_input = _NamedTextIOWrapper(
+            bytes_input, encoding=self.charset, name="<stdin>", mode="r"
+        )
+
+        if self.echo_stdin:
+            # Force unbuffered reads, otherwise TextIOWrapper reads a
+            # large chunk which is echoed early.
+            text_input._CHUNK_SIZE = 1  # type: ignore
+
+        sys.stdout = _NamedTextIOWrapper(
+            stream_mixer.stdout,
+            encoding=self.charset,
+            name="<stdout>",
+            mode="w",
+        )
+
+        sys.stderr = _NamedTextIOWrapper(
+            stream_mixer.stderr,
+            encoding=self.charset,
+            name="<stderr>",
+            mode="w",
+            errors="backslashreplace",
+        )
+
+        @_pause_echo(echo_input)  # type: ignore
+        def visible_input(prompt: str | None = None) -> str:
+            sys.stdout.write(prompt or "")
+            try:
+                val = next(text_input).rstrip("\r\n")
+            except StopIteration as e:
+                raise EOFError() from e
+            sys.stdout.write(f"{val}\n")
+            sys.stdout.flush()
+            return val
+
+        @_pause_echo(echo_input)  # type: ignore
+        def hidden_input(prompt: str | None = None) -> str:
+            sys.stdout.write(f"{prompt or ''}\n")
+            sys.stdout.flush()
+            try:
+                return next(text_input).rstrip("\r\n")
+            except StopIteration as e:
+                raise EOFError() from e
+
+        @_pause_echo(echo_input)  # type: ignore
+        def _getchar(echo: bool) -> str:
+            char = sys.stdin.read(1)
+
+            if echo:
+                sys.stdout.write(char)
+
+            sys.stdout.flush()
+            return char
+
+        default_color = color
+
+        def should_strip_ansi(
+            stream: t.IO[t.Any] | None = None, color: bool | None = None
+        ) -> bool:
+            if color is None:
+                return not default_color
+            return not color
+
+        old_visible_prompt_func = termui.visible_prompt_func
+        old_hidden_prompt_func = termui.hidden_prompt_func
+        old__getchar_func = termui._getchar
+        old_should_strip_ansi = utils.should_strip_ansi  # type: ignore
+        old__compat_should_strip_ansi = _compat.should_strip_ansi
+        old_pdb_init = pdb.Pdb.__init__
+        termui.visible_prompt_func = visible_input
+        termui.hidden_prompt_func = hidden_input
+        termui._getchar = _getchar
+        utils.should_strip_ansi = should_strip_ansi  # type: ignore
+        _compat.should_strip_ansi = should_strip_ansi
+
+        def _patched_pdb_init(
+            self: pdb.Pdb,
+            completekey: str = "tab",
+            stdin: t.IO[str] | None = None,
+            stdout: t.IO[str] | None = None,
+            **kwargs: t.Any,
+        ) -> None:
+            """Default ``pdb.Pdb`` to real terminal streams during
+            ``CliRunner`` isolation.
+
+            Without this patch, ``pdb.Pdb.__init__`` inherits from
+            ``cmd.Cmd`` which falls back to ``sys.stdin``/``sys.stdout``
+            when no explicit streams are provided. During isolation
+            those are ``BytesIO``-backed wrappers, so the debugger
+            reads from an empty buffer and writes to captured output,
+            making interactive debugging impossible.
+
+            By defaulting to ``sys.__stdin__``/``sys.__stdout__`` (the
+            original terminal streams Python preserves regardless of
+            redirection), debuggers can interact with the user while
+            ``click.echo`` output is still captured normally.
+
+            This covers ``pdb.set_trace()``, ``breakpoint()``,
+            ``pdb.post_mortem()``, and debuggers that subclass
+            ``pdb.Pdb`` (ipdb, pdbpp). Explicit ``stdin``/``stdout``
+            arguments are honored and not overridden. Debuggers that
+            do not subclass ``pdb.Pdb`` (pudb, debugpy) are not
+            covered.
+            """
+            if stdin is None:
+                stdin = sys.__stdin__
+            if stdout is None:
+                stdout = sys.__stdout__
+            old_pdb_init(
+                self, completekey=completekey, stdin=stdin, stdout=stdout, **kwargs
+            )
+
+        pdb.Pdb.__init__ = _patched_pdb_init  # type: ignore[assignment]
+
+        old_env = {}
+        try:
+            for key, value in env.items():
+                old_env[key] = os.environ.get(key)
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            yield (stream_mixer.stdout, stream_mixer.stderr, stream_mixer.output)
+        finally:
+            for key, value in old_env.items():
+                if value is None:
+                    try:
+                        del os.environ[key]
+                    except Exception:
+                        pass
+                else:
+                    os.environ[key] = value
+            sys.stdout = old_stdout
+            sys.stderr = old_stderr
+            sys.stdin = old_stdin
+            termui.visible_prompt_func = old_visible_prompt_func
+            termui.hidden_prompt_func = old_hidden_prompt_func
+            termui._getchar = old__getchar_func
+            utils.should_strip_ansi = old_should_strip_ansi  # type: ignore
+            _compat.should_strip_ansi = old__compat_should_strip_ansi
+            formatting.FORCED_WIDTH = old_forced_width
+            pdb.Pdb.__init__ = old_pdb_init  # type: ignore[method-assign]
+
+    def invoke(
+        self,
+        cli: Command,
+        args: str | cabc.Sequence[str] | None = None,
+        input: str | bytes | t.IO[t.Any] | None = None,
+        env: cabc.Mapping[str, str | None] | None = None,
+        catch_exceptions: bool | None = None,
+        color: bool = False,
+        **extra: t.Any,
+    ) -> Result:
+        """Invokes a command in an isolated environment.  The arguments are
+        forwarded directly to the command line script, the `extra` keyword
+        arguments are passed to the :meth:`~clickpkg.Command.main` function of
+        the command.
+
+        This returns a :class:`Result` object.
+
+        :param cli: the command to invoke
+        :param args: the arguments to invoke. It may be given as an iterable
+                     or a string. When given as string it will be interpreted
+                     as a Unix shell command. More details at
+                     :func:`shlex.split`.
+        :param input: the input data for `sys.stdin`.
+        :param env: the environment overrides.
+        :param catch_exceptions: Whether to catch any other exceptions than
+                                 ``SystemExit``. If :data:`None`, the value
+                                 from :class:`CliRunner` is used.
+        :param extra: the keyword arguments to pass to :meth:`main`.
+        :param color: whether the output should contain color codes. The
+                      application can still override this explicitly.
+
+        .. versionadded:: 8.2
+            The result object has the ``output_bytes`` attribute with
+            the mix of ``stdout_bytes`` and ``stderr_bytes``, as the user would
+            see it in its terminal.
+
+        .. versionchanged:: 8.2
+            The result object always returns the ``stderr_bytes`` stream.
+
+        .. versionchanged:: 8.0
+            The result object has the ``return_value`` attribute with
+            the value returned from the invoked command.
+
+        .. versionchanged:: 4.0
+            Added the ``color`` parameter.
+
+        .. versionchanged:: 3.0
+            Added the ``catch_exceptions`` parameter.
+
+        .. versionchanged:: 3.0
+            The result object has the ``exc_info`` attribute with the
+            traceback if available.
+        """
+        exc_info = None
+        if catch_exceptions is None:
+            catch_exceptions = self.catch_exceptions
+
+        # Set up fd capture before isolation replaces sys.stdout and sys.stderr.
+        cap_out: _FDCapture | None = None
+        cap_err: _FDCapture | None = None
+
+        if self.capture == "fd":
+            cap_out = _FDCapture(1)
+            cap_err = _FDCapture(2)
+            try:
+                cap_out.start()
+                cap_err.start()
+            except OSError:
+                cap_out = cap_err = None
+
+        with self.isolation(input=input, env=env, color=color) as outstreams:
+            # Point the captured streams' fileno() at the saved (original)
+            # fd so that C-level consumers like faulthandler keep working
+            # while fd 1/2 are redirected to the capture tmpfile.
+            if cap_out is not None and cap_err is not None:
+                sys.stdout._original_fd = cap_out.saved_fd  # type: ignore[union-attr]
+                sys.stderr._original_fd = cap_err.saved_fd  # type: ignore[union-attr]
+
+            return_value = None
+            exception: BaseException | None = None
+            exit_code = 0
+
+            if isinstance(args, str):
+                args = shlex.split(args)
+
+            try:
+                prog_name = extra.pop("prog_name")
+            except KeyError:
+                prog_name = self.get_default_prog_name(cli)
+
+            try:
+                return_value = cli.main(args=args or (), prog_name=prog_name, **extra)
+            except SystemExit as e:
+                exc_info = sys.exc_info()
+                e_code = t.cast("int | t.Any | None", e.code)
+
+                if e_code is None:
+                    e_code = 0
+
+                if e_code != 0:
+                    exception = e
+
+                if not isinstance(e_code, int):
+                    sys.stdout.write(str(e_code))
+                    sys.stdout.write("\n")
+                    e_code = 1
+
+                exit_code = e_code
+
+            except Exception as e:
+                if not catch_exceptions:
+                    raise
+                exception = e
+                exit_code = 1
+                exc_info = sys.exc_info()
+            finally:
+                sys.stdout.flush()
+                sys.stderr.flush()
+
+                # Stop fd capture and merge the captured bytes into
+                # the stdout/stderr BytesIO streams. BytesIOCopy mirrors
+                # those writes into outstreams[2] automatically.
+                if cap_out is not None and cap_err is not None:
+                    fd_out = cap_out.stop()
+                    fd_err = cap_err.stop()
+                    if fd_out:
+                        outstreams[0].write(fd_out)
+                    if fd_err:
+                        outstreams[1].write(fd_err)
+
+                stdout = outstreams[0].getvalue()
+                stderr = outstreams[1].getvalue()
+                output = outstreams[2].getvalue()
+
+        return Result(
+            runner=self,
+            stdout_bytes=stdout,
+            stderr_bytes=stderr,
+            output_bytes=output,
+            return_value=return_value,
+            exit_code=exit_code,
+            exception=exception,
+            exc_info=exc_info,  # type: ignore
+        )
+
+    @contextlib.contextmanager
+    def isolated_filesystem(
+        self, temp_dir: str | os.PathLike[str] | None = None
+    ) -> cabc.Generator[str]:
+        """A context manager that creates a temporary directory and
+        changes the current working directory to it. This isolates tests
+        that affect the contents of the CWD to prevent them from
+        interfering with each other.
+
+        .. warning::
+            This helper predates Python 3 and modern pytest, and is not
+            thread-safe: it relies on :func:`os.chdir`, which mutates
+            process-global state, and :meth:`invoke` swaps the
+            process-global standard streams too. Parallelize tests with
+            processes (``pytest-xdist``), not threads. Locking the
+            runner (:pr:`3511`, :pr:`3520`, :pr:`3530`) and a
+            ``set_filesystem()`` API (:issue:`3123`) were declined:
+            neither removes the global-state mutation. See :issue:`3700`
+            and :issue:`3501`.
+
+        :param temp_dir: Create the temporary directory under this
+            directory. If given, the created directory is not removed
+            when exiting.
+
+        .. deprecated:: 8.5.0
+            Will be removed in Click 9.0. Use
+            :class:`tempfile.TemporaryDirectory` or pytest's
+            ``tmp_path`` fixture with absolute paths instead.
+
+        .. versionchanged:: 8.0
+            Added the ``temp_dir`` parameter.
+        """
+        import warnings
+
+        warnings.warn(
+            "'isolated_filesystem' is deprecated and will be removed in Click"
+            " 9.0. Use 'tempfile.TemporaryDirectory' or pytest's 'tmp_path'"
+            " fixture with absolute paths instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+
+        cwd = os.getcwd()
+        dt = tempfile.mkdtemp(dir=temp_dir)
+        os.chdir(dt)
+
+        try:
+            yield dt
+        finally:
+            os.chdir(cwd)
+
+            if temp_dir is None:
+                import shutil
+
+                try:
+                    shutil.rmtree(dt)
+                except OSError:
+                    pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..0eb84621d3ceb92e240f1523e2e58d5951335633
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/types.py
@@ -0,0 +1,1422 @@
+from __future__ import annotations
+
+import abc
+import collections.abc as cabc
+import enum
+import os
+import stat
+import sys
+import typing as t
+import uuid
+from datetime import datetime
+from gettext import gettext as _
+from gettext import ngettext
+
+from ._compat import _get_argv_encoding
+from ._compat import open_stream
+from .exceptions import BadParameter
+from .utils import _LazyFile
+from .utils import _safecall
+from .utils import format_filename
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    from .core import Context
+    from .core import Parameter
+    from .shell_completion import CompletionItem
+
+_ValueT = t.TypeVar("_ValueT")
+_ValueT_contra = t.TypeVar("_ValueT_contra", contravariant=True)
+_ValueT_co = t.TypeVar("_ValueT_co", covariant=True)
+
+# The input type parameter of ParamType defaults to Any. TypeVar defaults
+# (PEP 696) landed in typing on Python 3.13, so type checkers get the
+# default from typing_extensions, which is never imported at runtime. On
+# older Pythons the runtime TypeVar carries no default;
+# ParamType.__class_getitem__ fills in the omitted parameter instead.
+if t.TYPE_CHECKING:
+    _InputT_contra = te.TypeVar("_InputT_contra", contravariant=True, default=t.Any)
+elif sys.version_info >= (3, 13):
+    _InputT_contra = t.TypeVar("_InputT_contra", contravariant=True, default=t.Any)
+else:
+    _InputT_contra = t.TypeVar("_InputT_contra", contravariant=True)
+
+_FloatValueT = t.TypeVar("_FloatValueT", bound=float)
+_FloatValueT_co = t.TypeVar("_FloatValueT_co", bound=float, covariant=True)
+
+
+class ParamTypeInfoDict(t.TypedDict):
+    param_type: str
+    name: str
+
+
+class ParamType(t.Generic[_ValueT_co, _InputT_contra], abc.ABC):
+    """Represents the type of a parameter. Validates and converts values
+    from the command line or Python into the correct type.
+
+    To implement a custom type, subclass and implement at least the
+    following:
+
+    -   The :attr:`name` class attribute must be set.
+    -   Calling an instance of the type with ``None`` must return
+        ``None``. This is already implemented by default.
+    -   :meth:`convert` must convert string values to the correct type.
+    -   :meth:`convert` must accept values that are already the correct
+        type.
+    -   It must be able to convert a value if the ``ctx`` and ``param``
+        arguments are ``None``. This can occur when converting prompt
+        input.
+
+    .. versionchanged:: 8.4.0
+        Now a generic abstract base class. Parameterize with the
+        converted value type (``ParamType[int]`` for an integer-returning
+        type) so that :meth:`convert` and downstream consumers carry the
+        narrowed return type.
+
+    .. versionchanged:: 8.5.0
+        Accepts a second optional type parameter for the input value type
+        that :meth:`convert` accepts (``ParamType[int, str]`` for a type
+        converting strings to integers), defaulting to ``Any``.
+    """
+
+    is_composite: t.ClassVar[bool] = False
+    arity: int = 1  # read-only
+
+    #: the descriptive name of this type
+    name: str
+
+    #: if a list of this type is expected and the value is pulled from a
+    #: string environment variable, this is what splits it up.  `None`
+    #: means any whitespace.  For all parameters the general rule is that
+    #: whitespace splits them up.  The exception are paths and files which
+    #: are split by ``os.path.pathsep`` by default (":" on Unix and ";" on
+    #: Windows).
+    envvar_list_splitter: t.ClassVar[str | None] = None
+
+    if sys.version_info < (3, 13):
+        # ``_InputT_contra`` carries its ``Any`` default only for type
+        # checkers: ``TypeVar(default=...)`` (PEP 696) is unavailable at
+        # runtime before Python 3.13. Fill in the omitted input type
+        # parameter by hand so ``ParamType[int]`` keeps working.
+        def __class_getitem__(cls, params: t.Any) -> t.Any:
+            if cls is ParamType:
+                if not isinstance(params, tuple):
+                    params = (params,)
+                if len(params) == 1:
+                    params = (*params, t.Any)
+            # Checkers cannot see Generic.__class_getitem__ through super().
+            return super().__class_getitem__(params)  # type: ignore[misc]
+
+    def to_info_dict(self) -> ParamTypeInfoDict:
+        """Gather information that could be useful for a tool generating
+        user-facing documentation.
+
+        Use :meth:`click.Context.to_info_dict` to traverse the entire
+        CLI structure.
+
+        .. versionadded:: 8.0
+        """
+        # The class name without the "ParamType" suffix.
+        param_type = type(self).__name__.partition("ParamType")[0]
+        param_type = param_type.partition("ParameterType")[0]
+
+        # Custom subclasses might not remember to set a name.
+        if hasattr(self, "name"):
+            name = self.name
+        else:
+            name = param_type
+
+        return {"param_type": param_type, "name": name}
+
+    @t.overload
+    def __call__(
+        self,
+        value: None,
+        param: Parameter | None = None,
+        ctx: Context | None = None,
+    ) -> None: ...
+
+    @t.overload
+    def __call__(
+        self,
+        value: _InputT_contra,
+        param: Parameter | None = None,
+        ctx: Context | None = None,
+    ) -> _ValueT_co: ...
+
+    def __call__(
+        self,
+        value: _InputT_contra | None,
+        param: Parameter | None = None,
+        ctx: Context | None = None,
+    ) -> _ValueT_co | None:
+        if value is not None:
+            return self.convert(value, param, ctx)
+        return None
+
+    def get_metavar(self, param: Parameter, ctx: Context) -> str | None:
+        """Returns the metavar default for this param if it provides one."""
+
+    def get_missing_message(self, param: Parameter, ctx: Context | None) -> str | None:
+        """Optionally might return extra information about a missing
+        parameter.
+
+        .. versionadded:: 2.0
+        """
+
+    def convert(
+        self, value: _InputT_contra, param: Parameter | None, ctx: Context | None
+    ) -> _ValueT_co:
+        """Convert the value to the correct type. This is not called if
+        the value is ``None`` (the missing value).
+
+        This must accept string values from the command line, as well as
+        values that are already the correct type. It may also convert
+        other compatible types.
+
+        The ``param`` and ``ctx`` arguments may be ``None`` in certain
+        situations, such as when converting prompt input.
+
+        If the value cannot be converted, call :meth:`fail` with a
+        descriptive message.
+
+        :param value: The value to convert.
+        :param param: The parameter that is using this type to convert
+            its value. May be ``None``.
+        :param ctx: The current context that arrived at this value. May
+            be ``None``.
+        """
+        # The default returns the value as-is so subclasses that only customize
+        # metadata are not forced to redeclare ``convert``.
+        return t.cast("_ValueT_co", value)
+
+    def split_envvar_value(self, rv: str) -> cabc.Sequence[str]:
+        """Given a value from an environment variable this splits it up
+        into small chunks depending on the defined envvar list splitter.
+
+        If the splitter is set to `None`, which means that whitespace splits,
+        then leading and trailing whitespace is ignored.  Otherwise, leading
+        and trailing splitters usually lead to empty items being included.
+        """
+        return (rv or "").split(self.envvar_list_splitter)
+
+    def fail(
+        self,
+        message: str,
+        param: Parameter | None = None,
+        ctx: Context | None = None,
+    ) -> t.NoReturn:
+        """Helper method to fail with an invalid value message."""
+        raise BadParameter(message, ctx=ctx, param=param)
+
+    def shell_complete(
+        self, ctx: Context, param: Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Return a list of
+        :class:`~click.shell_completion.CompletionItem` objects for the
+        incomplete value. Most types do not provide completions, but
+        some do, and this allows custom types to provide custom
+        completions as well.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        return []
+
+
+class CompositeParamType(ParamType[_ValueT_co]):
+    is_composite: t.ClassVar[bool] = True
+
+    @property
+    @abc.abstractmethod
+    def arity(self) -> int: ...  # type: ignore[override]
+
+
+if t.TYPE_CHECKING:
+    # on Python 3.10 this will raise a TypeError
+
+    class FuncParamTypeInfoDict(
+        ParamTypeInfoDict,
+        t.Generic[_ValueT_contra, _ValueT_co],
+    ):
+        func: t.Callable[[_ValueT_contra], _ValueT_co]
+else:
+
+    class FuncParamTypeInfoDict(ParamTypeInfoDict):
+        func: t.Callable[[t.Any], t.Any]
+
+
+class FuncParamType(ParamType[_ValueT_co], t.Generic[_ValueT_contra, _ValueT_co]):
+    name: str
+    func: t.Callable[[_ValueT_contra], _ValueT_co]
+
+    def __init__(self, func: t.Callable[[_ValueT_contra], _ValueT_co]) -> None:
+        self.name = func.__name__
+        self.func = func
+
+    def to_info_dict(self) -> FuncParamTypeInfoDict[_ValueT_contra, _ValueT_co]:
+        return {"func": self.func, **super().to_info_dict()}
+
+    def convert(
+        self, value: _ValueT_contra, param: Parameter | None, ctx: Context | None
+    ) -> _ValueT_co:
+        try:
+            return self.func(value)
+        except ValueError as exc:
+            message = str(exc)
+
+            if not message:
+                try:
+                    message = str(value)
+                except UnicodeError:
+                    message = t.cast("bytes", value).decode("utf-8", "replace")
+
+            self.fail(message, param, ctx)
+
+
+class UnprocessedParamType(ParamType[t.Any]):
+    name = "text"
+
+    def convert(
+        self, value: _ValueT, param: Parameter | None, ctx: Context | None
+    ) -> _ValueT:
+        return value
+
+    def __repr__(self) -> str:
+        return "UNPROCESSED"
+
+
+class StringParamType(ParamType[str]):
+    name = "text"
+
+    def convert(
+        self, value: t.Any, param: Parameter | None, ctx: Context | None
+    ) -> str:
+        if isinstance(value, bytes):
+            enc = _get_argv_encoding()
+            try:
+                return value.decode(enc)
+            except UnicodeError:
+                fs_enc = sys.getfilesystemencoding()
+                if fs_enc != enc:
+                    try:
+                        return value.decode(fs_enc)
+                    except UnicodeError:
+                        return value.decode("utf-8", "replace")
+                else:
+                    return value.decode("utf-8", "replace")
+        return str(value)
+
+    def __repr__(self) -> str:
+        return "STRING"
+
+
+if t.TYPE_CHECKING:
+    # on Python 3.10 this will raise a TypeError
+
+    class ChoiceInfoDict(ParamTypeInfoDict, t.Generic[_ValueT_co]):
+        choices: tuple[_ValueT_co, ...]
+        case_sensitive: bool
+else:
+
+    class ChoiceInfoDict(ParamTypeInfoDict):
+        choices: tuple[t.Any, ...]
+        case_sensitive: bool
+
+
+class Choice(ParamType[_ValueT_co], t.Generic[_ValueT_co]):
+    """The choice type allows a value to be checked against a fixed set
+    of supported values.
+
+    You may pass any iterable value which will be converted to a tuple
+    and thus will only be iterated once.
+
+    The resulting value will always be one of the originally passed choices.
+    See :meth:`normalize_choice` for more info on the mapping of strings
+    to choices. See :ref:`choice-opts` for an example.
+
+    :param case_sensitive: Set to false to make choices case
+        insensitive. Defaults to true.
+
+    .. versionchanged:: 8.4.0
+        Now generic in the choice value type. Parameterize with the type of
+        the choice values (``Choice[HashType]`` for an enum, ``Choice[str]``
+        for plain strings) to enable type-checked consumers.
+
+    .. versionchanged:: 8.2.0
+        Non-``str`` ``choices`` are now supported. It can additionally be any
+        iterable. Before you were not recommended to pass anything but a list or
+        tuple.
+
+    .. versionadded:: 8.2.0
+        Choice normalization can be overridden via :meth:`normalize_choice`.
+    """
+
+    name: str = "choice"
+
+    choices: tuple[_ValueT_co, ...]
+    case_sensitive: bool
+
+    def __init__(
+        self, choices: cabc.Iterable[_ValueT_co], case_sensitive: bool = True
+    ) -> None:
+        self.choices = tuple(choices)
+        self.case_sensitive = case_sensitive
+
+    def to_info_dict(self) -> ChoiceInfoDict[_ValueT_co]:
+        return {
+            "choices": self.choices,
+            "case_sensitive": self.case_sensitive,
+            **super().to_info_dict(),
+        }
+
+    def _normalized_mapping(
+        self, ctx: Context | None = None
+    ) -> cabc.Mapping[_ValueT_co, str]:
+        """
+        Returns mapping where keys are the original choices and the values are
+        the normalized values that are accepted via the command line.
+
+        This is a simple wrapper around :meth:`normalize_choice`, use that
+        instead which is supported.
+        """
+        return {
+            choice: self.normalize_choice(
+                choice=choice,
+                ctx=ctx,
+            )
+            for choice in self.choices
+        }
+
+    def normalize_choice(self, choice: object, ctx: Context | None) -> str:
+        """
+        Normalize a choice value, used to map a passed string to a choice.
+        Each choice must have a unique normalized value.
+
+        By default uses :meth:`Context.token_normalize_func` and if not case
+        sensitive, convert it to a casefolded value.
+
+        .. versionadded:: 8.2.0
+        """
+        normed_value = choice.name if isinstance(choice, enum.Enum) else str(choice)
+
+        if ctx is not None and ctx.token_normalize_func is not None:
+            normed_value = ctx.token_normalize_func(normed_value)
+
+        if not self.case_sensitive:
+            normed_value = normed_value.casefold()
+
+        return normed_value
+
+    def get_metavar(self, param: Parameter, ctx: Context) -> str | None:
+        if param.param_type_name == "option" and not param.show_choices:  # type: ignore[attr-defined]
+            choice_metavars = [
+                convert_type(type(choice)).name.upper() for choice in self.choices
+            ]
+            choices_str = "|".join([*dict.fromkeys(choice_metavars)])
+        else:
+            choices_str = "|".join(
+                [str(i) for i in self._normalized_mapping(ctx=ctx).values()]
+            )
+
+        # Use curly braces to indicate a required argument.
+        if param.required and param.param_type_name == "argument":
+            return f"{{{choices_str}}}"
+
+        # Use square braces to indicate an option or optional argument.
+        return f"[{choices_str}]"
+
+    def get_missing_message(self, param: Parameter, ctx: Context | None) -> str:
+        """
+        Message shown when no choice is passed.
+
+        .. versionchanged:: 8.2.0 Added ``ctx`` argument.
+        """
+        return _("Choose from:\n\t{choices}").format(
+            choices=",\n\t".join(self._normalized_mapping(ctx=ctx).values())
+        )
+
+    def convert(
+        self, value: t.Any, param: Parameter | None, ctx: Context | None
+    ) -> _ValueT_co:
+        """
+        For a given value from the parser, normalize it and find its
+        matching normalized value in the list of choices. Then return the
+        matched "original" choice.
+        """
+        normed_value = self.normalize_choice(choice=value, ctx=ctx)
+        normalized_mapping = self._normalized_mapping(ctx=ctx)
+
+        try:
+            return next(
+                original
+                for original, normalized in normalized_mapping.items()
+                if normalized == normed_value
+            )
+        except StopIteration:
+            self.fail(
+                self.get_invalid_choice_message(value=value, ctx=ctx),
+                param=param,
+                ctx=ctx,
+            )
+
+    def get_invalid_choice_message(self, value: t.Any, ctx: Context | None) -> str:
+        """Get the error message when the given choice is invalid.
+
+        :param value: The invalid value.
+
+        .. versionadded:: 8.2
+        """
+        choices_str = ", ".join(map(repr, self._normalized_mapping(ctx=ctx).values()))
+        return ngettext(
+            "{value!r} is not {choice}.",
+            "{value!r} is not one of {choices}.",
+            len(self.choices),
+        ).format(value=value, choice=choices_str, choices=choices_str)
+
+    def __repr__(self) -> str:
+        return _("Choice({choices})").format(choices=list(self.choices))
+
+    def shell_complete(
+        self, ctx: Context, param: Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Complete choices that start with the incomplete value.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        str_choices = [self.normalize_choice(choice, ctx) for choice in self.choices]
+        if self.case_sensitive:
+            matched = (c for c in str_choices if c.startswith(incomplete))
+        else:
+            incomplete = incomplete.lower()
+            matched = (c for c in str_choices if c.lower().startswith(incomplete))
+
+        return [CompletionItem(c) for c in matched]
+
+
+class DateTimeInfoDict(ParamTypeInfoDict):
+    formats: cabc.Sequence[str]
+
+
+class DateTime(ParamType[datetime]):
+    """The DateTime type converts date strings into `datetime` objects.
+
+    The format strings which are checked are configurable, but default to some
+    common (non-timezone aware) ISO 8601 formats.
+
+    When specifying *DateTime* formats, you should only pass a list or a tuple.
+    Other iterables, like generators, may lead to surprising results.
+
+    The format strings are processed using ``datetime.strptime``, and this
+    consequently defines the format strings which are allowed.
+
+    Parsing is tried using each format, in order, and the first format which
+    parses successfully is used.
+
+    :param formats: A list or tuple of date format strings, in the order in
+                    which they should be tried. Defaults to
+                    ``'%Y-%m-%d'``, ``'%Y-%m-%dT%H:%M:%S'``,
+                    ``'%Y-%m-%d %H:%M:%S'``.
+    """
+
+    name = "datetime"
+
+    formats: cabc.Sequence[str]
+
+    def __init__(self, formats: cabc.Sequence[str] | None = None):
+        self.formats = formats or [
+            "%Y-%m-%d",
+            "%Y-%m-%dT%H:%M:%S",
+            "%Y-%m-%d %H:%M:%S",
+        ]
+
+    def to_info_dict(self) -> DateTimeInfoDict:
+        return {"formats": self.formats, **super().to_info_dict()}
+
+    def get_metavar(self, param: Parameter, ctx: Context) -> str:
+        return f"[{'|'.join(self.formats)}]"
+
+    def _try_to_convert_date(self, value: t.Any, format: str) -> datetime | None:
+        try:
+            return datetime.strptime(value, format)
+        except ValueError:
+            return None
+
+    def convert(
+        self, value: t.Any, param: Parameter | None, ctx: Context | None
+    ) -> datetime:
+        if isinstance(value, datetime):
+            return value
+
+        for format in self.formats:
+            converted = self._try_to_convert_date(value, format)
+
+            if converted is not None:
+                return converted
+
+        formats_str = ", ".join(map(repr, self.formats))
+        self.fail(
+            ngettext(
+                "{value!r} does not match the format {format}.",
+                "{value!r} does not match the formats {formats}.",
+                len(self.formats),
+            ).format(value=value, format=formats_str, formats=formats_str),
+            param,
+            ctx,
+        )
+
+    def __repr__(self) -> str:
+        return "DateTime"
+
+
+class _NumberParamTypeBase(
+    ParamType[_ValueT_co], t.Generic[_ValueT_contra, _ValueT_co]
+):
+    _number_class: t.Callable[[_ValueT_contra], _ValueT_co]
+
+    def convert(
+        self, value: _ValueT_contra, param: Parameter | None, ctx: Context | None
+    ) -> _ValueT_co:
+        try:
+            return self._number_class(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid {number_type}.").format(
+                    value=value, number_type=self.name
+                ),
+                param,
+                ctx,
+            )
+
+
+if t.TYPE_CHECKING:
+    # on Python 3.10 this will raise a TypeError
+
+    class NumberRangeInfoDict(ParamTypeInfoDict, t.Generic[_FloatValueT_co]):
+        min: _FloatValueT_co | None
+        max: _FloatValueT_co | None
+        min_open: bool
+        max_open: bool
+        clamp: bool
+else:
+
+    class NumberRangeInfoDict(ParamTypeInfoDict):
+        min: t.Any | None
+        max: t.Any | None
+        min_open: bool
+        max_open: bool
+        clamp: bool
+
+
+class _NumberRangeBase(
+    _NumberParamTypeBase[_ValueT_contra, _FloatValueT_co],
+    t.Generic[_ValueT_contra, _FloatValueT_co],
+):
+    min: _FloatValueT_co | None
+    max: _FloatValueT_co | None
+    min_open: bool
+    max_open: bool
+    clamp: bool
+
+    def __init__(
+        self,
+        min: _FloatValueT_co | None = None,
+        max: _FloatValueT_co | None = None,
+        min_open: bool = False,
+        max_open: bool = False,
+        clamp: bool = False,
+    ) -> None:
+        self.min = min
+        self.max = max
+        self.min_open = min_open
+        self.max_open = max_open
+        self.clamp = clamp
+
+    def to_info_dict(self) -> NumberRangeInfoDict[_FloatValueT_co]:
+        return {
+            "min": self.min,
+            "max": self.max,
+            "min_open": self.min_open,
+            "max_open": self.max_open,
+            "clamp": self.clamp,
+            **super().to_info_dict(),
+        }
+
+    def convert(
+        self, value: _ValueT_contra, param: Parameter | None, ctx: Context | None
+    ) -> _FloatValueT_co:
+        import operator
+
+        rv = super().convert(value, param, ctx)
+        min = self.min
+        max = self.max
+        lt_min: bool = min is not None and (
+            operator.le if self.min_open else operator.lt
+        )(rv, min)
+        gt_max: bool = max is not None and (
+            operator.ge if self.max_open else operator.gt
+        )(rv, max)
+
+        if self.clamp:
+            if min is not None and lt_min:
+                return self._clamp(min, 1, self.min_open)
+
+            if max is not None and gt_max:
+                return self._clamp(max, -1, self.max_open)
+
+        if lt_min or gt_max:
+            self.fail(
+                _("{value} is not in the range {range}.").format(
+                    value=rv, range=self._describe_range()
+                ),
+                param,
+                ctx,
+            )
+
+        return rv
+
+    @abc.abstractmethod
+    def _clamp(
+        # Covariant type variables cannot be used in input positions, so we use a
+        # separate method-scoped type variable instead.
+        self: _NumberRangeBase[t.Any, _FloatValueT],
+        bound: _FloatValueT,
+        dir: t.Literal[1, -1],
+        open: bool,
+    ) -> _FloatValueT:
+        """Find the valid value to clamp to bound in the given
+        direction.
+
+        :param bound: The boundary value.
+        :param dir: 1 or -1 indicating the direction to move.
+        :param open: If true, the range does not include the bound.
+        """
+        ...
+
+    def _describe_range(self) -> str:
+        """Describe the range for use in help text."""
+        if self.min is None:
+            op = "<" if self.max_open else "<="
+            return f"x{op}{self.max}"
+
+        if self.max is None:
+            op = ">" if self.min_open else ">="
+            return f"x{op}{self.min}"
+
+        lop = "<" if self.min_open else "<="
+        rop = "<" if self.max_open else "<="
+        return f"{self.min}{lop}x{rop}{self.max}"
+
+    def __repr__(self) -> str:
+        clamp = " clamped" if self.clamp else ""
+        return f"<{type(self).__name__} {self._describe_range()}{clamp}>"
+
+
+class IntParamType(_NumberParamTypeBase[t.SupportsInt | t.SupportsIndex, int]):
+    name = "integer"
+    _number_class = int
+
+    def __repr__(self) -> str:
+        return "INT"
+
+
+class IntRange(_NumberRangeBase[int, int], IntParamType):
+    """Restrict an :data:`click.INT` value to a range of accepted
+    values. See :ref:`ranges`.
+
+    If ``min`` or ``max`` are not passed, any value is accepted in that
+    direction. If ``min_open`` or ``max_open`` are enabled, the
+    corresponding boundary is not included in the range.
+
+    If ``clamp`` is enabled, a value outside the range is clamped to the
+    boundary instead of failing.
+
+    .. versionchanged:: 8.0
+        Added the ``min_open`` and ``max_open`` parameters.
+    """
+
+    name = "integer range"
+
+    def _clamp(self, bound: int, dir: t.Literal[1, -1], open: bool) -> int:
+        if not open:
+            return bound
+
+        return bound + dir
+
+
+class FloatParamType(_NumberParamTypeBase[t.SupportsFloat | t.SupportsIndex, float]):
+    name = "float"
+    _number_class = float
+
+    def __repr__(self) -> str:
+        return "FLOAT"
+
+
+class FloatRange(_NumberRangeBase[float, float], FloatParamType):
+    """Restrict a :data:`click.FLOAT` value to a range of accepted
+    values. See :ref:`ranges`.
+
+    If ``min`` or ``max`` are not passed, any value is accepted in that
+    direction. If ``min_open`` or ``max_open`` are enabled, the
+    corresponding boundary is not included in the range.
+
+    If ``clamp`` is enabled, a value outside the range is clamped to the
+    boundary instead of failing. This is not supported if either
+    boundary is marked ``open``.
+
+    .. versionchanged:: 8.0
+        Added the ``min_open`` and ``max_open`` parameters.
+    """
+
+    name = "float range"
+
+    def __init__(
+        self,
+        min: float | None = None,
+        max: float | None = None,
+        min_open: bool = False,
+        max_open: bool = False,
+        clamp: bool = False,
+    ) -> None:
+        super().__init__(
+            min=min, max=max, min_open=min_open, max_open=max_open, clamp=clamp
+        )
+
+        if (min_open or max_open) and clamp:
+            raise TypeError("Clamping is not supported for open bounds.")
+
+    def _clamp(self, bound: float, dir: t.Literal[1, -1], open: bool) -> float:
+        if not open:
+            return bound
+
+        # Could use math.nextafter here, but clamping an
+        # open float range doesn't seem to be particularly useful. It's
+        # left up to the user to write a callback to do it if needed.
+        raise RuntimeError("Clamping is not supported for open bounds.")
+
+
+class BoolParamType(ParamType[bool]):
+    name = "boolean"
+
+    bool_states: dict[str, bool] = {
+        "1": True,
+        "0": False,
+        "yes": True,
+        "no": False,
+        "true": True,
+        "false": False,
+        "on": True,
+        "off": False,
+        "t": True,
+        "f": False,
+        "y": True,
+        "n": False,
+        # Absence of value is considered False.
+        "": False,
+    }
+    """A mapping of string values to boolean states.
+
+    Mapping is inspired by :py:attr:`configparser.ConfigParser.BOOLEAN_STATES`
+    and extends it.
+
+    .. caution::
+        String values are lower-cased, as the ``str_to_bool`` comparison function
+        below is case-insensitive.
+
+    .. warning::
+        The mapping is not exhaustive, and does not cover all possible boolean strings
+        representations. It will remains as it is to avoid endless bikeshedding.
+
+        Future work my be considered to make this mapping user-configurable from public
+        API.
+    """
+
+    @staticmethod
+    def str_to_bool(value: str | bool) -> bool | None:
+        """Convert a string to a boolean value.
+
+        If the value is already a boolean, it is returned as-is. If the value is a
+        string, it is stripped of whitespaces and lower-cased, then checked against
+        the known boolean states pre-defined in the `BoolParamType.bool_states` mapping
+        above.
+
+        Returns `None` if the value does not match any known boolean state.
+        """
+        if isinstance(value, bool):
+            return value
+        return BoolParamType.bool_states.get(value.strip().lower())
+
+    def convert(
+        self, value: t.Any, param: Parameter | None, ctx: Context | None
+    ) -> bool:
+        normalized = self.str_to_bool(value)
+        if normalized is None:
+            self.fail(
+                _(
+                    "{value!r} is not a valid boolean. Recognized values: {states}"
+                ).format(value=value, states=", ".join(sorted(self.bool_states))),
+                param,
+                ctx,
+            )
+        return normalized
+
+    def __repr__(self) -> str:
+        return "BOOL"
+
+
+class UUIDParameterType(ParamType[uuid.UUID]):
+    name = "uuid"
+
+    def convert(
+        self, value: uuid.UUID | str, param: Parameter | None, ctx: Context | None
+    ) -> uuid.UUID:
+        if isinstance(value, uuid.UUID):
+            return value
+
+        value = value.strip()
+
+        try:
+            return uuid.UUID(value)
+        except ValueError:
+            self.fail(
+                _("{value!r} is not a valid UUID.").format(value=value), param, ctx
+            )
+
+    def __repr__(self) -> str:
+        return "UUID"
+
+
+class FileInfoDict(ParamTypeInfoDict):
+    mode: str
+    encoding: str | None
+
+
+class File(ParamType[t.IO[t.Any]]):
+    """Declares a parameter to be a file for reading or writing.  The file
+    is automatically closed once the context tears down (after the command
+    finished working).
+
+    Files can be opened for reading or writing.  The special value ``-``
+    indicates stdin or stdout depending on the mode.
+
+    By default, the file is opened for reading text data, but it can also be
+    opened in binary mode or for writing.  The encoding parameter can be used
+    to force a specific encoding.
+
+    The `lazy` flag controls if the file should be opened immediately or upon
+    first IO. The default is to be non-lazy for standard input and output
+    streams as well as files opened for reading, `lazy` otherwise. When opening a
+    file lazily for reading, it is still opened temporarily for validation, but
+    will not be held open until first IO. lazy is mainly useful when opening
+    for writing to avoid creating the file until it is needed.
+
+    Files can also be opened atomically in which case all writes go into a
+    separate file in the same folder and upon completion the file will
+    be moved over to the original location.  This is useful if a file
+    regularly read by other users is modified.
+
+    See :ref:`file-args` for more information.
+
+    .. versionchanged:: 2.0
+        Added the ``atomic`` parameter.
+    """
+
+    name = "filename"
+    envvar_list_splitter: t.ClassVar[str] = os.path.pathsep
+
+    mode: str
+    encoding: str | None
+    errors: str | None
+    lazy: bool | None
+    atomic: bool
+
+    def __init__(
+        self,
+        mode: str = "r",
+        encoding: str | None = None,
+        errors: str | None = "strict",
+        lazy: bool | None = None,
+        atomic: bool = False,
+    ) -> None:
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.lazy = lazy
+        self.atomic = atomic
+
+    def to_info_dict(self) -> FileInfoDict:
+        return {
+            "mode": self.mode,
+            "encoding": self.encoding,
+            **super().to_info_dict(),
+        }
+
+    def resolve_lazy_flag(self, value: str | os.PathLike[str]) -> bool:
+        if self.lazy is not None:
+            return self.lazy
+        if os.fspath(value) == "-":
+            return False
+        elif "w" in self.mode:
+            return True
+        return False
+
+    def convert(
+        self,
+        value: str | os.PathLike[str] | t.IO[t.Any],
+        param: Parameter | None,
+        ctx: Context | None,
+    ) -> t.IO[t.Any]:
+        if _is_file_like(value):
+            return value
+
+        try:
+            lazy = self.resolve_lazy_flag(value)
+
+            if lazy:
+                lf = _LazyFile(
+                    value, self.mode, self.encoding, self.errors, atomic=self.atomic
+                )
+
+                if ctx is not None:
+                    ctx.call_on_close(lf.close_intelligently)
+
+                return t.cast("t.IO[t.Any]", lf)
+
+            f, should_close = open_stream(
+                value, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
+
+            # If a context is provided, we automatically close the file
+            # at the end of the context execution (or flush out).  If a
+            # context does not exist, it's the caller's responsibility to
+            # properly close the file.  This for instance happens when the
+            # type is used with prompts.
+            if ctx is not None:
+                if should_close:
+                    ctx.call_on_close(_safecall(f.close))
+                else:
+                    ctx.call_on_close(_safecall(f.flush))
+
+            return f
+        except OSError as e:
+            self.fail(
+                f"'{format_filename(value)}': {e.strerror}",
+                param,
+                ctx,
+            )
+
+    def shell_complete(
+        self, ctx: Context, param: Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Return a special completion marker that tells the completion
+        system to use the shell to provide file path completions.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        return [CompletionItem(incomplete, type="file")]
+
+
+def _is_file_like(value: t.Any) -> te.TypeIs[t.IO[t.Any]]:
+    return hasattr(value, "read") or hasattr(value, "write")
+
+
+class PathInfoDict(ParamTypeInfoDict):
+    exists: bool
+    file_okay: bool
+    dir_okay: bool
+    writable: bool
+    readable: bool
+    allow_dash: bool
+
+
+class Path(ParamType[str | bytes | os.PathLike[str]]):
+    """The ``Path`` type is similar to the :class:`File` type, but
+    returns the filename instead of an open file. Various checks can be
+    enabled to validate the type of file and permissions.
+
+    :param exists: The file or directory needs to exist for the value to
+        be valid. If this is not set to ``True``, and the file does not
+        exist, then all further checks are silently skipped.
+    :param file_okay: Allow a file as a value.
+    :param dir_okay: Allow a directory as a value.
+    :param readable: if true, a readable check is performed.
+    :param writable: if true, a writable check is performed.
+    :param executable: if true, an executable check is performed.
+    :param resolve_path: Make the value absolute and resolve any
+        symlinks. A ``~`` is not expanded, as this is supposed to be
+        done by the shell only.
+    :param allow_dash: Allow a single dash as a value, which indicates
+        a standard stream (but does not open it). Use
+        :func:`~click.open_file` to handle opening this value.
+    :param path_type: Convert the incoming path value to this type. If
+        ``None``, keep Python's default, which is ``str``. Useful to
+        convert to :class:`pathlib.Path`.
+
+    .. versionchanged:: 8.1
+        Added the ``executable`` parameter.
+
+    .. versionchanged:: 8.0
+        Allow passing ``path_type=pathlib.Path``.
+
+    .. versionchanged:: 6.0
+        Added the ``allow_dash`` parameter.
+    """
+
+    envvar_list_splitter: t.ClassVar[str] = os.path.pathsep
+
+    exists: bool
+    file_okay: bool
+    dir_okay: bool
+    readable: bool
+    writable: bool
+    executable: bool
+    resolve_path: bool
+    allow_dash: bool
+    name: str
+
+    def __init__(
+        self,
+        exists: bool = False,
+        file_okay: bool = True,
+        dir_okay: bool = True,
+        writable: bool = False,
+        readable: bool = True,
+        resolve_path: bool = False,
+        allow_dash: bool = False,
+        path_type: type | None = None,
+        executable: bool = False,
+    ) -> None:
+        self.exists = exists
+        self.file_okay = file_okay
+        self.dir_okay = dir_okay
+        self.readable = readable
+        self.writable = writable
+        self.executable = executable
+        self.resolve_path = resolve_path
+        self.allow_dash = allow_dash
+        self.type: type | None = path_type
+
+        if self.file_okay and not self.dir_okay:
+            self.name = _("file")
+        elif self.dir_okay and not self.file_okay:
+            self.name = _("directory")
+        else:
+            self.name = _("path")
+
+    def to_info_dict(self) -> PathInfoDict:
+        return {
+            "exists": self.exists,
+            "file_okay": self.file_okay,
+            "dir_okay": self.dir_okay,
+            "writable": self.writable,
+            "readable": self.readable,
+            "allow_dash": self.allow_dash,
+            **super().to_info_dict(),
+        }
+
+    def coerce_path_result(
+        self, value: str | os.PathLike[str]
+    ) -> str | bytes | os.PathLike[str]:
+        if self.type is not None and not isinstance(value, self.type):
+            if self.type is str:
+                return os.fsdecode(value)
+            elif self.type is bytes:
+                return os.fsencode(value)
+            else:
+                return t.cast("os.PathLike[str]", self.type(value))
+
+        return value
+
+    def convert(
+        self,
+        value: str | os.PathLike[str],
+        param: Parameter | None,
+        ctx: Context | None,
+    ) -> str | bytes | os.PathLike[str]:
+        rv = value
+
+        dash = b"-" if isinstance(rv, bytes) else "-"
+        is_dash = self.file_okay and self.allow_dash and rv == dash
+
+        if not is_dash:
+            if self.resolve_path:
+                rv = os.path.realpath(rv)
+
+            try:
+                st = os.stat(rv)
+            except OSError:
+                if not self.exists:
+                    return self.coerce_path_result(rv)
+                self.fail(
+                    _("{name} {filename!r} does not exist.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if not self.file_okay and stat.S_ISREG(st.st_mode):
+                self.fail(
+                    _("{name} {filename!r} is a file.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+            if not self.dir_okay and stat.S_ISDIR(st.st_mode):
+                self.fail(
+                    _("{name} {filename!r} is a directory.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.readable and not os.access(rv, os.R_OK):
+                self.fail(
+                    _("{name} {filename!r} is not readable.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.writable and not os.access(rv, os.W_OK):
+                self.fail(
+                    _("{name} {filename!r} is not writable.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+            if self.executable and not os.access(value, os.X_OK):
+                self.fail(
+                    _("{name} {filename!r} is not executable.").format(
+                        name=self.name.title(), filename=format_filename(value)
+                    ),
+                    param,
+                    ctx,
+                )
+
+        return self.coerce_path_result(rv)
+
+    def shell_complete(
+        self, ctx: Context, param: Parameter, incomplete: str
+    ) -> list[CompletionItem]:
+        """Return a special completion marker that tells the completion
+        system to use the shell to provide path completions for only
+        directories or any paths.
+
+        :param ctx: Invocation context for this command.
+        :param param: The parameter that is requesting completion.
+        :param incomplete: Value being completed. May be empty.
+
+        .. versionadded:: 8.0
+        """
+        from click.shell_completion import CompletionItem
+
+        type = "dir" if self.dir_okay and not self.file_okay else "file"
+        return [CompletionItem(incomplete, type=type)]
+
+
+class TupleInfoDict(ParamTypeInfoDict):
+    types: cabc.Sequence[ParamTypeInfoDict]
+
+
+class Tuple(CompositeParamType[tuple[t.Any, ...]]):
+    """The default behavior of Click is to apply a type on a value directly.
+    This works well in most cases, except for when `nargs` is set to a fixed
+    count and different types should be used for different items.  In this
+    case the :class:`Tuple` type can be used.  This type can only be used
+    if `nargs` is set to a fixed number.
+
+    For more information see :ref:`tuple-type`.
+
+    This can be selected by using a Python tuple literal as a type.
+
+    :param types: a list of types that should be used for the tuple items.
+    """
+
+    def __init__(self, types: cabc.Sequence[type[t.Any] | ParamType[t.Any]]) -> None:
+        self.types: cabc.Sequence[ParamType[t.Any]] = [convert_type(ty) for ty in types]
+
+    def to_info_dict(self) -> TupleInfoDict:
+        return {
+            "types": [ty.to_info_dict() for ty in self.types],
+            **super().to_info_dict(),
+        }
+
+    @property
+    def name(self) -> str:  # type: ignore[override]
+        return f"<{' '.join(ty.name for ty in self.types)}>"
+
+    @property
+    def arity(self) -> int:  # type: ignore[override]
+        return len(self.types)
+
+    def convert(
+        self, value: t.Any, param: Parameter | None, ctx: Context | None
+    ) -> tuple[t.Any, ...]:
+        len_type = len(self.types)
+        len_value = len(value)
+
+        if len_value != len_type:
+            self.fail(
+                ngettext(
+                    "{len_type} values are required, but {len_value} was given.",
+                    "{len_type} values are required, but {len_value} were given.",
+                    len_value,
+                ).format(len_type=len_type, len_value=len_value),
+                param=param,
+                ctx=ctx,
+            )
+
+        return tuple(
+            ty(x, param, ctx) for ty, x in zip(self.types, value, strict=False)
+        )
+
+
+def _guess_type(
+    ty: type[t.Any] | ParamType[t.Any] | None,
+    default: t.Any | None,
+) -> type[t.Any] | tuple[type[t.Any], ...] | ParamType[t.Any] | None:
+    """Infer a type from *ty* or *default*.
+
+    Returns *ty* unchanged when it is not ``None``.  Otherwise inspects
+    *default* to produce a ``type``, a ``tuple`` of types (for tuple
+    defaults), or ``None``.
+    """
+    if ty is not None:
+        return ty
+
+    if default is None:
+        return None
+
+    if not isinstance(default, (tuple, list)):
+        return type(default)
+
+    # If the default is empty, return None so convert_type falls
+    # through to STRING.
+    if not default:
+        return None
+
+    item = default[0]
+
+    # A sequence of iterables needs to detect the inner types.
+    # Can't call convert_type recursively because that would
+    # incorrectly unwind the tuple to a single type.
+    if isinstance(item, (tuple, list)):
+        return tuple(map(type, item))
+
+    return type(item)
+
+
+@t.overload
+def convert_type(ty: None, default: None = None) -> StringParamType: ...
+@t.overload
+def convert_type(
+    ty: type | ParamType[t.Any], default: t.Any | None = None
+) -> ParamType[t.Any]: ...
+@t.overload
+def convert_type(
+    ty: t.Any | None, default: t.Any | None = None
+) -> ParamType[t.Any]: ...
+def convert_type(
+    ty: t.Any | None = None, default: t.Any | None = None
+) -> ParamType[t.Any]:
+    """Find the most appropriate :class:`ParamType` for the given Python
+    type. If the type isn't provided, it can be inferred from a default
+    value.
+    """
+    guessed = _guess_type(ty, default)
+    is_guessed = guessed is not ty
+
+    if isinstance(guessed, tuple):
+        return Tuple(guessed)
+
+    if isinstance(guessed, ParamType):
+        return guessed
+
+    if guessed is str or guessed is None:
+        return STRING
+
+    if guessed is int:
+        return INT
+
+    if guessed is float:
+        return FLOAT
+
+    if guessed is bool:
+        return BOOL
+
+    if is_guessed:
+        return STRING
+
+    if __debug__:
+        try:
+            if issubclass(guessed, ParamType):
+                raise AssertionError(
+                    f"Attempted to use an uninstantiated parameter type ({guessed})."
+                )
+        except TypeError:
+            # guessed is an instance (correct), so issubclass fails.
+            pass
+
+    return FuncParamType(guessed)
+
+
+#: A dummy parameter type that just does nothing.  From a user's
+#: perspective this appears to just be the same as `STRING` but
+#: internally no string conversion takes place if the input was bytes.
+#: This is usually useful when working with file paths as they can
+#: appear in bytes and unicode.
+#:
+#: For path related uses the :class:`Path` type is a better choice but
+#: there are situations where an unprocessed type is useful which is why
+#: it is provided.
+#:
+#: .. versionadded:: 4.0
+UNPROCESSED: t.Final[UnprocessedParamType] = UnprocessedParamType()
+
+#: A unicode string parameter type which is the implicit default.  This
+#: can also be selected by using ``str`` as type.
+STRING: t.Final[StringParamType] = StringParamType()
+
+#: An integer parameter.  This can also be selected by using ``int`` as
+#: type.
+INT: t.Final[IntParamType] = IntParamType()
+
+#: A floating point value parameter.  This can also be selected by using
+#: ``float`` as type.
+FLOAT: t.Final[FloatParamType] = FloatParamType()
+
+#: A boolean parameter.  This is the default for boolean flags.  This can
+#: also be selected by using ``bool`` as a type.
+BOOL: t.Final[BoolParamType] = BoolParamType()
+
+#: A UUID parameter.
+UUID: t.Final[UUIDParameterType] = UUIDParameterType()
+
+
+class OptionHelpExtra(t.TypedDict, total=False):
+    envvars: tuple[str, ...]
+    default: str
+    range: str
+    required: str
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..b529eb04b34189f08e1211c95c7c8a30ca778490
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/click/utils.py
@@ -0,0 +1,688 @@
+from __future__ import annotations
+
+import collections.abc as cabc
+import os
+import re
+import sys
+import typing as t
+from functools import update_wrapper
+from gettext import gettext as _
+from types import ModuleType
+from types import TracebackType
+
+from ._compat import _default_text_stderr
+from ._compat import _default_text_stdout
+from ._compat import _find_binary_writer
+from ._compat import binary_streams
+from ._compat import open_stream
+from ._compat import should_strip_ansi
+from ._compat import strip_ansi
+from ._compat import text_streams
+from ._compat import WIN
+from .globals import resolve_color_default
+
+if t.TYPE_CHECKING:
+    import typing_extensions as te
+
+    P = te.ParamSpec("P")
+
+R = t.TypeVar("R")
+
+
+def _posixify(name: str) -> str:
+    return "-".join(name.split()).lower()
+
+
+def _safecall(func: t.Callable[P, R]) -> t.Callable[P, R | None]:
+    """Wraps a function so that it swallows exceptions.
+
+    :meta private:
+    """
+
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R | None:
+        try:
+            return func(*args, **kwargs)
+        except Exception:
+            pass
+        return None
+
+    return update_wrapper(wrapper, func)
+
+
+def make_str(value: t.Any) -> str:
+    """Converts a value into a valid string."""
+    if isinstance(value, bytes):
+        try:
+            return value.decode(sys.getfilesystemencoding())
+        except UnicodeError:
+            return value.decode("utf-8", "replace")
+    return str(value)
+
+
+def _make_default_short_help(help: str, max_length: int = 45) -> str:
+    """Returns a condensed version of help string.
+
+    :meta private:
+    """
+    # Consider only the first paragraph.
+    paragraph_end = help.find("\n\n")
+
+    if paragraph_end != -1:
+        help = help[:paragraph_end]
+
+    # Collapse newlines, tabs, and spaces.
+    words = help.split()
+
+    if not words:
+        return ""
+
+    # The first paragraph started with a "no rewrap" marker, ignore it.
+    if words[0] == "\b":
+        words = words[1:]
+
+    total_length = 0
+    last_index = len(words) - 1
+
+    for i, word in enumerate(words):
+        total_length += len(word) + (i > 0)
+
+        if total_length > max_length:  # too long, truncate
+            break
+
+        if word[-1] == ".":  # sentence end, truncate without "..."
+            return " ".join(words[: i + 1])
+
+        if total_length == max_length and i != last_index:
+            break  # not at sentence end, truncate with "..."
+    else:
+        return " ".join(words)  # no truncation needed
+
+    # Account for the length of the suffix.
+    total_length += len("...")
+
+    # remove words until the length is short enough
+    while i > 0:
+        total_length -= len(words[i]) + (i > 0)
+
+        if total_length <= max_length:
+            break
+
+        i -= 1
+
+    return " ".join(words[:i]) + "..."
+
+
+class _LazyFile:
+    """A lazy file works like a regular file but it does not fully open
+    the file but it does perform some basic checks early to see if the
+    filename parameter does make sense.  This is useful for safely opening
+    files for writing.
+
+    :meta private:
+    """
+
+    name: str
+    mode: str
+    encoding: str | None
+    errors: str | None
+    atomic: bool
+    _f: t.IO[t.Any] | None
+    should_close: bool
+
+    def __init__(
+        self,
+        filename: str | os.PathLike[str],
+        mode: str = "r",
+        encoding: str | None = None,
+        errors: str | None = "strict",
+        atomic: bool = False,
+    ) -> None:
+        self.name = os.fspath(filename)
+        self.mode = mode
+        self.encoding = encoding
+        self.errors = errors
+        self.atomic = atomic
+
+        if self.name == "-":
+            self._f, self.should_close = open_stream(filename, mode, encoding, errors)
+        else:
+            if "r" in mode:
+                # Open and close the file in case we're opening it for
+                # reading so that we can catch at least some errors in
+                # some cases early.
+                open(filename, mode).close()
+            self._f = None
+            self.should_close = True
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self.open(), name)
+
+    def __repr__(self) -> str:
+        if self._f is not None:
+            return repr(self._f)
+        return f"<unopened file '{format_filename(self.name)}' {self.mode}>"
+
+    def open(self) -> t.IO[t.Any]:
+        """Opens the file if it's not yet open.  This call might fail with
+        a :exc:`FileError`.  Not handling this error will produce an error
+        that Click shows.
+        """
+        if self._f is not None:
+            return self._f
+        try:
+            rv, self.should_close = open_stream(
+                self.name, self.mode, self.encoding, self.errors, atomic=self.atomic
+            )
+        except OSError as e:
+            from .exceptions import FileError
+
+            raise FileError(self.name, hint=e.strerror) from e
+        self._f = rv
+        return rv
+
+    def close(self) -> None:
+        """Closes the underlying file, no matter what."""
+        if self._f is not None:
+            self._f.close()
+
+    def close_intelligently(self) -> None:
+        """This function only closes the file if it was opened by the lazy
+        file wrapper.  For instance this will never close stdin.
+        """
+        if self.should_close:
+            self.close()
+
+    def __enter__(self) -> _LazyFile:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close_intelligently()
+
+    def __iter__(self) -> cabc.Iterator[t.AnyStr]:
+        self.open()
+        return iter(self._f)  # type: ignore
+
+
+class _KeepOpenFile:
+    """Proxy a file object but keep it open across a ``with`` block.
+
+    Wraps a borrowed file (such as ``sys.stdin`` or ``sys.stdout``) so that
+    leaving a ``with`` block does not close it, as used by :func:`open_file`
+    for the ``-`` filename. The caller stays responsible for the file: an
+    explicit :meth:`close` still passes through to the wrapped object.
+
+    Dunder methods are proxied explicitly: implicit special-method lookups
+    bypass :meth:`__getattr__`, because Python resolves them on the type rather
+    than the instance.
+
+    :meta private:
+    """
+
+    _file: t.IO[t.Any]
+
+    def __init__(self, file: t.IO[t.Any]) -> None:
+        self._file = file
+
+    def __getattr__(self, name: str) -> t.Any:
+        return getattr(self._file, name)
+
+    def __enter__(self) -> _KeepOpenFile:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        pass
+
+    def __repr__(self) -> str:
+        return repr(self._file)
+
+    def __iter__(self) -> cabc.Iterator[t.AnyStr]:
+        return iter(self._file)
+
+
+def echo(
+    message: object = None,
+    file: t.IO[t.Any] | None = None,
+    nl: bool = True,
+    err: bool = False,
+    color: bool | None = None,
+) -> None:
+    """Print a message and newline to stdout or a file. This should be
+    used instead of :func:`print` because it provides better support
+    for different data, files, and environments.
+
+    Compared to :func:`print`, this does the following:
+
+    -   Ensures that the output encoding is not misconfigured on Linux.
+    -   Supports Unicode in the Windows console.
+    -   Supports writing to binary outputs, and supports writing bytes
+        to text outputs.
+    -   Removes ANSI color and style codes if the output does not look
+        like an interactive terminal.
+    -   Always flushes the output.
+
+    :param message: The string or bytes to output. Other objects are
+        converted to strings.
+    :param file: The file to write to. Defaults to ``stdout``.
+    :param err: Write to ``stderr`` instead of ``stdout``.
+    :param nl: Print a newline after the message. Enabled by default.
+    :param color: Force showing or hiding colors and other styles. By
+        default Click will remove color if the output does not look like
+        an interactive terminal.
+
+    .. versionchanged:: 8.5.0
+        Colorama is no longer used for color on Windows.
+
+    .. versionchanged:: 6.0
+        Support Unicode output on the Windows console. Click does not
+        modify ``sys.stdout``, so ``sys.stdout.write()`` and ``print()``
+        will still not support Unicode.
+
+    .. versionchanged:: 4.0
+        Added the ``color`` parameter.
+
+    .. versionadded:: 3.0
+        Added the ``err`` parameter.
+
+    .. versionchanged:: 2.0
+        Support colors on Windows if colorama is installed.
+    """
+    if file is None:
+        if err:
+            file = _default_text_stderr()
+        else:
+            file = _default_text_stdout()
+
+        # There are no standard streams attached to write to. For example,
+        # pythonw on Windows.
+        if file is None:
+            return
+
+    match message:
+        case str() | bytes() | bytearray():
+            out = message
+        case None:
+            out = ""
+        case _:
+            out = str(message)
+
+    if nl:
+        if isinstance(out, str):
+            out += "\n"
+        else:
+            out += b"\n"
+
+    if not out:
+        file.flush()
+        return
+
+    # If there is a message and the value looks like bytes, we manually
+    # need to find the binary stream and write the message in there.
+    # This is done separately so that most stream types will work as you
+    # would expect. Eg: you can write to StringIO for other cases.
+    if isinstance(out, (bytes, bytearray)):
+        binary_file = _find_binary_writer(file)
+        if binary_file is not None:
+            file.flush()
+            binary_file.write(out)
+            binary_file.flush()
+            return
+
+    # ANSI style code support. For no message or bytes, nothing happens.
+    # When outputting to a file instead of a terminal, strip codes.
+    elif should_strip_ansi(file, resolve_color_default(color)):
+        out = strip_ansi(out)
+
+    file.write(out)  # type: ignore
+    file.flush()
+
+
+def _get_binary_stream(name: t.Literal["stdin", "stdout", "stderr"]) -> t.BinaryIO:
+    """Returns a system stream for byte processing.
+
+    .. deprecated:: 8.5.0
+        Will be removed in Click 9.0.
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+
+    :meta private:
+    """
+    opener = binary_streams.get(name)
+    if opener is None:
+        raise TypeError(_("Unknown standard stream '{name}'").format(name=name))
+    return opener()
+
+
+def _get_text_stream(
+    name: t.Literal["stdin", "stdout", "stderr"],
+    encoding: str | None = None,
+    errors: str | None = "strict",
+) -> t.TextIO:
+    """Returns a system stream for text processing.
+
+    .. deprecated:: 8.5.0
+        Will be removed in Click 9.0.
+
+    This usually returns a wrapped stream around a binary stream returned from
+    :func:`get_binary_stream` but it also can take shortcuts for already
+    correctly configured streams.
+
+
+    :param name: the name of the stream to open.  Valid names are ``'stdin'``,
+                 ``'stdout'`` and ``'stderr'``
+    :param encoding: overrides the detected default encoding.
+    :param errors: overrides the default error mode.
+    :meta private:
+    """
+    opener = text_streams.get(name)
+    if opener is None:
+        raise TypeError(_("Unknown standard stream '{name}'").format(name=name))
+    return opener(encoding, errors)
+
+
+def open_file(
+    filename: str | os.PathLike[str],
+    mode: str = "r",
+    encoding: str | None = None,
+    errors: str | None = "strict",
+    lazy: bool = False,
+    atomic: bool = False,
+) -> t.IO[t.Any]:
+    """Open a file, with extra behavior to handle ``'-'`` to indicate
+    a standard stream, lazy open on write, and atomic write. Similar to
+    the behavior of the :class:`~click.File` param type.
+
+    If ``'-'`` is given to open ``stdout`` or ``stdin``, the stream is
+    wrapped so that using it in a context manager will not close it.
+    This makes it possible to use the function without accidentally
+    closing a standard stream:
+
+    .. code-block:: python
+
+        with open_file(filename) as f:
+            ...
+
+    :param filename: The name or Path of the file to open, or ``'-'`` for
+        ``stdin``/``stdout``.
+    :param mode: The mode in which to open the file.
+    :param encoding: The encoding to decode or encode a file opened in
+        text mode.
+    :param errors: The error handling mode.
+    :param lazy: Wait to open the file until it is accessed. For read
+        mode, the file is temporarily opened to raise access errors
+        early, then closed until it is read again.
+    :param atomic: Write to a temporary file and replace the given file
+        on close.
+
+    .. versionadded:: 3.0
+    """
+    if lazy:
+        return t.cast(
+            "t.IO[t.Any]", _LazyFile(filename, mode, encoding, errors, atomic=atomic)
+        )
+
+    f, should_close = open_stream(filename, mode, encoding, errors, atomic=atomic)
+
+    if not should_close:
+        f = t.cast("t.IO[t.Any]", _KeepOpenFile(f))
+
+    return f
+
+
+def format_filename(
+    filename: str | bytes | os.PathLike[str] | os.PathLike[bytes],
+    shorten: bool = False,
+) -> str:
+    """Format a filename as a string for display. Ensures the filename can be
+    displayed by replacing any invalid bytes or surrogate escapes in the name
+    with the replacement character ``�``.
+
+    Invalid bytes or surrogate escapes will raise an error when written to a
+    stream with ``errors="strict"``. This will typically happen with ``stdout``
+    when the locale is something like ``en_GB.UTF-8``.
+
+    Many scenarios *are* safe to write surrogates though, due to PEP 538 and
+    PEP 540, including:
+
+    -   Writing to ``stderr``, which uses ``errors="backslashreplace"``.
+    -   The system has ``LANG=C.UTF-8``, ``C``, or ``POSIX``. Python opens
+        stdout and stderr with ``errors="surrogateescape"``.
+    -   None of ``LANG/LC_*`` are set. Python assumes ``LANG=C.UTF-8``.
+    -   Python is started in UTF-8 mode  with  ``PYTHONUTF8=1`` or ``-X utf8``.
+        Python opens stdout and stderr with ``errors="surrogateescape"``.
+
+    :param filename: formats a filename for UI display.  This will also convert
+                     the filename into unicode without failing.
+    :param shorten: this optionally shortens the filename to strip of the
+                    path that leads up to it.
+    """
+    if shorten:
+        filename = os.path.basename(filename)
+    else:
+        filename = os.fspath(filename)
+
+    if isinstance(filename, bytes):
+        filename = filename.decode(sys.getfilesystemencoding(), "replace")
+    else:
+        filename = filename.encode("utf-8", "surrogateescape").decode(
+            "utf-8", "replace"
+        )
+
+    return filename
+
+
+def get_app_dir(app_name: str, roaming: bool = True, force_posix: bool = False) -> str:
+    r"""Returns the config folder for the application.  The default behavior
+    is to return whatever is most appropriate for the operating system.
+
+    To give you an idea, for an app called ``"Foo Bar"``, something like
+    the following folders could be returned:
+
+    Mac OS X:
+      ``~/Library/Application Support/Foo Bar``
+    Mac OS X (POSIX):
+      ``~/.foo-bar``
+    Unix:
+      ``~/.config/foo-bar``
+    Unix (POSIX):
+      ``~/.foo-bar``
+    Windows (roaming):
+      ``C:\Users\<user>\AppData\Roaming\Foo Bar``
+    Windows (not roaming):
+      ``C:\Users\<user>\AppData\Local\Foo Bar``
+
+    .. versionadded:: 2.0
+
+    :param app_name: the application name.  This should be properly capitalized
+                     and can contain whitespace.
+    :param roaming: controls if the folder should be roaming or not on Windows.
+                    Has no effect otherwise.
+    :param force_posix: if this is set to `True` then on any POSIX system the
+                        folder will be stored in the home folder with a leading
+                        dot instead of the XDG config home or darwin's
+                        application support folder.
+    """
+    if WIN:
+        key = "APPDATA" if roaming else "LOCALAPPDATA"
+        folder = os.environ.get(key)
+        if folder is None:
+            folder = os.path.expanduser("~")
+        return os.path.join(folder, app_name)
+    if force_posix:
+        return os.path.join(os.path.expanduser(f"~/.{_posixify(app_name)}"))
+    if sys.platform == "darwin":
+        return os.path.join(
+            os.path.expanduser("~/Library/Application Support"), app_name
+        )
+    return os.path.join(
+        os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")),
+        _posixify(app_name),
+    )
+
+
+class _PacifyFlushWrapper:
+    """This wrapper is used to catch and suppress BrokenPipeErrors resulting
+    from ``.flush()`` being called on broken pipe during the shutdown/final-GC
+    of the Python interpreter. Notably ``.flush()`` is always called on
+    ``sys.stdout`` and ``sys.stderr``. So as to have minimal impact on any
+    other cleanup code, and the case where the underlying file is not a broken
+    pipe, all calls and attributes are proxied.
+
+    :meta private:
+    """
+
+    wrapped: t.IO[t.Any]
+
+    def __init__(self, wrapped: t.IO[t.Any]) -> None:
+        self.wrapped = wrapped
+
+    def flush(self) -> None:
+        try:
+            self.wrapped.flush()
+        except OSError as e:
+            import errno
+
+            if e.errno != errno.EPIPE:
+                raise
+
+    def __getattr__(self, attr: str) -> t.Any:
+        return getattr(self.wrapped, attr)
+
+
+def _detect_program_name(
+    path: str | None = None, _main: ModuleType | None = None
+) -> str:
+    """Determine the command used to run the program, for use in help
+    text. If a file or entry point was executed, the file name is
+    returned. If ``python -m`` was used to execute a module or package,
+    ``python -m name`` is returned.
+
+    This doesn't try to be too precise, the goal is to give a concise
+    name for help text. Files are only shown as their name without the
+    path. ``python`` is only shown for modules, and the full path to
+    ``sys.executable`` is not shown.
+
+    :param path: The Python file being executed. Python puts this in
+        ``sys.argv[0]``, which is used by default.
+    :param _main: The ``__main__`` module. This should only be passed
+        during internal testing.
+
+    .. versionadded:: 8.0
+        Based on command args detection in the Werkzeug reloader.
+
+    :meta private:
+    """
+    if _main is None:
+        _main = sys.modules["__main__"]
+
+    if not path:
+        path = sys.argv[0]
+
+    # The value of __package__ indicates how Python was called. It may
+    # not exist if a setuptools script is installed as an egg. It may be
+    # set incorrectly for entry points created with pip on Windows.
+    # It is set to "" inside a Shiv or PEX zipapp.
+    if getattr(_main, "__package__", None) in {None, ""} or (
+        os.name == "nt"
+        and _main.__package__ == ""
+        and not os.path.exists(path)
+        and os.path.exists(f"{path}.exe")
+    ):
+        # Executed a file, like "python app.py".
+        return os.path.basename(path)
+
+    # Executed a module, like "python -m example".
+    # Rewritten by Python from "-m script" to "/path/to/script.py".
+    # Need to look at main module to determine how it was executed.
+    py_module = t.cast(str, _main.__package__)
+    name = os.path.splitext(os.path.basename(path))[0]
+
+    # A submodule like "example.cli".
+    if name != "__main__":
+        py_module = f"{py_module}.{name}"
+
+    return f"python -m {py_module.lstrip('.')}"
+
+
+def _expand_args(
+    args: cabc.Iterable[str],
+    *,
+    user: bool = True,
+    env: bool = True,
+    glob_recursive: bool = True,
+) -> list[str]:
+    """Simulate Unix shell expansion with Python functions.
+
+    See :func:`glob.glob`, :func:`os.path.expanduser`, and
+    :func:`os.path.expandvars`.
+
+    This is intended for use on Windows, where the shell does not do any
+    expansion. It may not exactly match what a Unix shell would do.
+
+    :param args: List of command line arguments to expand.
+    :param user: Expand user home directory.
+    :param env: Expand environment variables.
+    :param glob_recursive: ``**`` matches directories recursively.
+
+    .. versionchanged:: 8.1
+        Invalid glob patterns are treated as empty expansions rather
+        than raising an error.
+
+    .. versionadded:: 8.0
+
+    :meta private:
+    """
+    from glob import glob
+
+    out = []
+
+    for arg in args:
+        if user:
+            arg = os.path.expanduser(arg)
+
+        if env:
+            arg = os.path.expandvars(arg)
+
+        try:
+            matches = glob(arg, recursive=glob_recursive)
+        except re.error:
+            matches = []
+
+        if not matches:
+            out.append(arg)
+        else:
+            out.extend(matches)
+
+    return out
+
+
+def __getattr__(name: str) -> object:
+    import warnings
+
+    if name in {
+        "LazyFile",
+        "KeepOpenFile",
+        "make_default_short_help",
+        "PacifyFlushWrapper",
+        "safecall",
+        "get_text_stream",
+        "get_binary_stream",
+    }:
+        warnings.warn(
+            f"'click.utils.{name}' is deprecated and will be removed in Click 9.0.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return globals()[f"_{name}"]
+
+    raise AttributeError(name)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/distutils-precedence.pth b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/distutils-precedence.pth
new file mode 100644
index 0000000000000000000000000000000000000000..c659194195f07bd6f19b5522515551309af14a3d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/distutils-precedence.pth
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2638ce9e2500e572a5e0de7faed6661eb569d1b696fcba07b0dd223da5f5d224
+size 151
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/eglRenderer.cpython-311-x86_64-linux-gnu.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/eglRenderer.cpython-311-x86_64-linux-gnu.so
new file mode 100644
index 0000000000000000000000000000000000000000..197502176c0e93ca8cdd0bcd6f1cffa42f9833bd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/eglRenderer.cpython-311-x86_64-linux-gnu.so
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72178d234809f2f42123ebde623ca1f88719dc5be90f7f951da1a253e6f7fa42
+size 11939472
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..826b5a93e0ebc4d46d1d2db52de9e2cce6cc2374
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/METADATA
@@ -0,0 +1,38 @@
+Metadata-Version: 2.5
+Name: filelock
+Version: 4.2.4
+Summary: A platform independent file lock.
+Project-URL: Documentation, https://py-filelock.readthedocs.io
+Project-URL: Homepage, https://github.com/tox-dev/py-filelock
+Project-URL: Source, https://github.com/tox-dev/py-filelock
+Project-URL: Tracker, https://github.com/tox-dev/py-filelock/issues
+Maintainer-email: Bernát Gábor <gaborjbernat@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: application,cache,directory,log,user
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: 3.15
+Classifier: Topic :: Internet
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: System
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# filelock
+
+[![PyPI](https://img.shields.io/pypi/v/filelock)](https://pypi.org/project/filelock/)
+[![Supported Python versions](https://img.shields.io/pypi/pyversions/filelock.svg)](https://pypi.org/project/filelock/)
+[![Documentation status](https://readthedocs.org/projects/py-filelock/badge/?version=latest)](https://py-filelock.readthedocs.io/en/latest/?badge=latest)
+[![Downloads](https://static.pepy.tech/badge/filelock/month)](https://pepy.tech/project/filelock)
+[![check](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml/badge.svg)](https://github.com/tox-dev/py-filelock/actions/workflows/check.yaml)
+
+For more information checkout the [official documentation](https://py-filelock.readthedocs.io/en/latest/index.html).
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..ffc69805fa09faf83f8704c9ef57ec0d34583de1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/RECORD
@@ -0,0 +1,52 @@
+filelock-4.2.4.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+filelock-4.2.4.dist-info/METADATA,sha256=2ZwPcqerhMkktzQBiiilABUF_g-WKAxEYrhkMT7d21A,1976
+filelock-4.2.4.dist-info/RECORD,,
+filelock-4.2.4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+filelock-4.2.4.dist-info/licenses/LICENSE,sha256=YIyJ1QYK6ZIa3M8yNmlbxlSplG4SMj72wCHfoE4pTUg,1088
+filelock/__init__.py,sha256=LaXgCbdErp-ugbr3o5bzpYJMBwi1hg0_hO4_vrwP1lk,5693
+filelock/__pycache__/__init__.cpython-311.pyc,,
+filelock/__pycache__/_api.cpython-311.pyc,,
+filelock/__pycache__/_async.cpython-311.pyc,,
+filelock/__pycache__/_async_read_write.cpython-311.pyc,,
+filelock/__pycache__/_descriptor.cpython-311.pyc,,
+filelock/__pycache__/_error.cpython-311.pyc,,
+filelock/__pycache__/_identity.cpython-311.pyc,,
+filelock/__pycache__/_lease.cpython-311.pyc,,
+filelock/__pycache__/_marker.cpython-311.pyc,,
+filelock/__pycache__/_read_write.cpython-311.pyc,,
+filelock/__pycache__/_soft.cpython-311.pyc,,
+filelock/__pycache__/_soft_protocol.cpython-311.pyc,,
+filelock/__pycache__/_strict.cpython-311.pyc,,
+filelock/__pycache__/_unix.cpython-311.pyc,,
+filelock/__pycache__/_util.cpython-311.pyc,,
+filelock/__pycache__/_windows.cpython-311.pyc,,
+filelock/__pycache__/asyncio.cpython-311.pyc,,
+filelock/__pycache__/version.cpython-311.pyc,,
+filelock/_api.py,sha256=OUugdO27gcc_gdfVOJYo0C6Bv6lvXL8Fv84vT7le378,106170
+filelock/_async.py,sha256=jSqb-YUze8cjKaNrlJ2qlMdfN9s1DZbgRMnozp4kDZs,20487
+filelock/_async_read_write.py,sha256=Ts6N_p5-UQLDoYHJKE67NfFV6ZpIcpX0cuu3S55dXzQ,17947
+filelock/_descriptor.py,sha256=Z81x98R7RbN5aHgaRzu48i7c0Ktsheze6Yg5uvWrU0Y,3277
+filelock/_error.py,sha256=sZNfFV3wacnrGCrnOipucPbnHN78NPt1IDnlg1nON1k,3235
+filelock/_identity.py,sha256=s2Kk4SQI0C5en9lHsPkWOVvGzuyY_wgZl8JRSOn63_8,17183
+filelock/_lease.py,sha256=eK0xXpuccVNM8o1BXSQByBE4TaIVYQSbSvfbbS6dReY,19173
+filelock/_marker.py,sha256=dVjalDpcpwqIRF7VUvFK2tkVZ4OCthjmmIinKy9jhFE,7896
+filelock/_read_write.py,sha256=5e0gtCHfLArSNKYH0jGdBXuD60m7stQV8KhuYgUvqQU,68071
+filelock/_soft.py,sha256=fXLlCQKHzDHaXCuwU8bXZw6qgmF1LEKRWVifxnRhRyk,33064
+filelock/_soft_protocol.py,sha256=D64pnXMlM7ysKpdx0fNXhJJgiMcS9T2Qwsu2GpPs2i0,218
+filelock/_soft_rw/__init__.py,sha256=JAMF4NA010_Jq-nEgHHZgWHZ7Of9wI3PKHg24mDdX50,452
+filelock/_soft_rw/__pycache__/__init__.cpython-311.pyc,,
+filelock/_soft_rw/__pycache__/_async.cpython-311.pyc,,
+filelock/_soft_rw/__pycache__/_protocol.cpython-311.pyc,,
+filelock/_soft_rw/__pycache__/_storage.cpython-311.pyc,,
+filelock/_soft_rw/__pycache__/_sync.cpython-311.pyc,,
+filelock/_soft_rw/_async.py,sha256=v3q2adfqb9vQRwqhlctYdKZYlltJ4XutZcJ7IXuDy4M,16939
+filelock/_soft_rw/_protocol.py,sha256=O-ENv_XstRpIIDh4GnFoPNfkIg-xsDc8tVpsfBhrklA,30996
+filelock/_soft_rw/_storage.py,sha256=SbhhE8HQp7RcPo7BPnUNSEi8di2b6M7JwXHBh4EkuSc,13691
+filelock/_soft_rw/_sync.py,sha256=qVgup1GUig8fDSWLkl16z8_9UXojAcPJ_nZWl5BzIaI,37638
+filelock/_strict.py,sha256=iaEnG4QmSESjubZIhz0aq4Fq5cWmBy3STeim-8F6AZs,58570
+filelock/_unix.py,sha256=BLotMhNLFKTrW6zQ_qoI9qZGo3YqYfhGO_qP5W_p6Lw,10985
+filelock/_util.py,sha256=XW3K2JNfJapekS7YgUYBGiOFYcSf8A1cBqnKfU6jxzY,19280
+filelock/_windows.py,sha256=cDFvJN8dJtdDYjHYPt_kplvJCklD_yI7_UiaJkV-V80,38880
+filelock/asyncio.py,sha256=x3-lsFBKzEnPQR_2bQDoSD9ErdmV_3lw5rPyRq7AZc4,42865
+filelock/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+filelock/version.py,sha256=v35Uwrw-IApU2AA-2B77yCvOvNQ1Vh7gXvxfaJ9Vd14,520
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..39dc805011177e5b2a77e7afb5ec7187aeb3e34d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..291919c0b6f41d014767f6c877af9f7595fcff99
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock-4.2.4.dist-info/licenses/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Bernát Gábor and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..15a6a55e2102657d1d2778790fbfd0d592cce3e3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__init__.py
@@ -0,0 +1,174 @@
+"""
+A platform independent file lock that supports the with-statement.
+
+.. autodata:: filelock.__version__
+    :no-value:
+
+.. autodata:: filelock.OwnerMode
+
+.. autodata:: filelock.CompromiseReason
+
+"""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["filelock._descriptor", "filelock._error", "importlib"]
+
+import sys
+import warnings
+from importlib import import_module
+from typing import TYPE_CHECKING, Final
+
+from filelock._api import AcquireReturnProxy, BaseFileLock, CloseErrorPolicy, ContextErrorPolicy, LockOptions
+from filelock._descriptor import lock_descriptor, unlock_descriptor
+from filelock._error import LeaseSettingsMismatch, SoftFileLockLifetimeWarning, SoftFileLockProtocolError, Timeout
+from filelock._unix import UnixFileLock
+from filelock._unix import has_fcntl as _has_fcntl
+from filelock._windows import WindowsFileLock
+
+# Keeps ``filelock.version`` the string 4.0.12 exposed rather than the submodule.
+from filelock.version import version
+
+if TYPE_CHECKING:
+    from filelock import asyncio
+    from filelock._async_read_write import AsyncAcquireReadWriteReturnProxy, AsyncReadWriteLock
+    from filelock._lease import CompromiseReason, LeaseCompromise, SoftFileLease
+    from filelock._marker import MarkerSoftFileLock, OwnerMode, OwnerRecord
+    from filelock._read_write import ReadWriteLock
+    from filelock._soft import SoftFileLock
+    from filelock._soft_rw import AsyncAcquireSoftReadWriteReturnProxy, AsyncSoftReadWriteLock, SoftReadWriteLock
+    from filelock._strict import StrictSoftFileClaim, StrictSoftFileClaimState, StrictSoftFileLock
+    from filelock.asyncio import (
+        AsyncAcquireReturnProxy,
+        AsyncSoftFileLease,
+        AsyncSoftFileLock,
+        AsyncStrictSoftFileLock,
+        AsyncUnixFileLock,
+        AsyncWindowsFileLock,
+        BaseAsyncFileLock,
+    )
+
+#: version of the project as a string
+__version__: Final[str] = version
+
+#: ``True`` when :func:`fcntl.flock` is available. Off Windows, :data:`FileLock` then resolves to
+#: :class:`UnixFileLock`, otherwise to :class:`SoftFileLock`. Always ``False`` on Windows.
+#:
+#: :meta hide-value:
+has_fcntl: Final[bool] = _has_fcntl
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    _FileLock: type[BaseFileLock] = WindowsFileLock
+else:  # pragma: win32 no cover # ruff:ignore[collapsible-else-if]  # the else carries the win32 no-cover pragma
+    if has_fcntl:
+        _FileLock: type[BaseFileLock] = UnixFileLock
+    else:
+        from filelock._soft import SoftFileLock
+
+        _FileLock = SoftFileLock
+        warnings.warn("only soft file lock is available", stacklevel=2)
+
+if TYPE_CHECKING:
+    FileLock = SoftFileLock
+    AsyncFileLock = AsyncSoftFileLock
+else:
+    #: Alias for the lock, which should be used for the current platform.
+    FileLock = _FileLock
+
+# Importing asyncio and sqlite3 costs more than the rest of the package, so names that need them load on first access.
+_LAZY_ATTRIBUTES: Final[dict[str, str]] = {
+    "AsyncAcquireReadWriteReturnProxy": "._async_read_write",
+    "AsyncAcquireReturnProxy": ".asyncio",
+    "AsyncAcquireSoftReadWriteReturnProxy": "._soft_rw",
+    "AsyncFileLock": ".asyncio",
+    "AsyncReadWriteLock": "._async_read_write",
+    "AsyncSoftFileLease": ".asyncio",
+    "AsyncSoftFileLock": ".asyncio",
+    "AsyncSoftReadWriteLock": "._soft_rw",
+    "AsyncStrictSoftFileLock": ".asyncio",
+    "AsyncUnixFileLock": ".asyncio",
+    "AsyncWindowsFileLock": ".asyncio",
+    "BaseAsyncFileLock": ".asyncio",
+    "CompromiseReason": "._lease",
+    "LeaseCompromise": "._lease",
+    "MarkerSoftFileLock": "._marker",
+    "OwnerMode": "._marker",
+    "OwnerRecord": "._marker",
+    "ReadWriteLock": "._read_write",
+    "SoftFileLease": "._lease",
+    "SoftFileLock": "._soft",
+    "SoftReadWriteLock": "._soft_rw",
+    "StrictSoftFileClaim": "._strict",
+    "StrictSoftFileClaimState": "._strict",
+    "StrictSoftFileLock": "._strict",
+    "asyncio": ".asyncio",
+}
+
+
+def __getattr__(name: str) -> object:
+    if (module_name := _LAZY_ATTRIBUTES.get(name)) is None:
+        msg = f"module {__name__!r} has no attribute {name!r}"
+        raise AttributeError(msg)
+    try:
+        module = import_module(module_name, __name__)
+    except ImportError:  # pragma: lacks sqlite3
+        if module_name not in {"._read_write", "._async_read_write"}:
+            raise
+        value = None
+    else:
+        if name == "asyncio":
+            value = module
+        else:
+            value = getattr(module, f"Async{_FileLock.__name__}" if name == "AsyncFileLock" else name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted({*globals(), *_LAZY_ATTRIBUTES})
+
+
+__all__ = [
+    "AcquireReturnProxy",
+    "AsyncAcquireReadWriteReturnProxy",
+    "AsyncAcquireReturnProxy",
+    "AsyncAcquireSoftReadWriteReturnProxy",
+    "AsyncFileLock",
+    "AsyncReadWriteLock",
+    "AsyncSoftFileLease",
+    "AsyncSoftFileLock",
+    "AsyncSoftReadWriteLock",
+    "AsyncStrictSoftFileLock",
+    "AsyncUnixFileLock",
+    "AsyncWindowsFileLock",
+    "BaseAsyncFileLock",
+    "BaseFileLock",
+    "CloseErrorPolicy",
+    "CompromiseReason",
+    "ContextErrorPolicy",
+    "FileLock",
+    "LeaseCompromise",
+    "LeaseSettingsMismatch",
+    "LockOptions",
+    "MarkerSoftFileLock",
+    "OwnerMode",
+    "OwnerRecord",
+    "ReadWriteLock",
+    "SoftFileLease",
+    "SoftFileLock",
+    "SoftFileLockLifetimeWarning",
+    "SoftFileLockProtocolError",
+    "SoftReadWriteLock",
+    "StrictSoftFileClaim",
+    "StrictSoftFileClaimState",
+    "StrictSoftFileLock",
+    "Timeout",
+    "UnixFileLock",
+    "WindowsFileLock",
+    "__version__",
+    "asyncio",
+    "has_fcntl",
+    "lock_descriptor",
+    "unlock_descriptor",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d90c39aee44912beb2aa9327e5ab82f97ec3fe2a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..65cac981b86504bafc8b9098e3ced9767bb3ec87
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_api.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f4f36d75a5ef9d19bbfe41bf0d717e91508d1fd804cfb89a1a36f1db01d73885
+size 123427
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c2f5c76a83ad099fb167ccd1d33fd0214926bb6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async_read_write.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async_read_write.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f0b3a15406e3727e1a88a44232e2a88c7a950fe4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_async_read_write.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_descriptor.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_descriptor.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27b3a7164af7e0d6f6bdd0b6a4c3d3b1c68241c9
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_descriptor.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12f5f6a37db26bae8a5847a7cd33ce294784471b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_error.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_identity.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_identity.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..73f6f4803e894e64d6b8c5d55d31f08be478562f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_identity.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_lease.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_lease.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f4fb21d00bb2b2e03452debd460e97f94c4c46f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_lease.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_marker.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_marker.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bcc8ac005630622a1f0b6e72de7f276b45faf862
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_marker.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_read_write.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_read_write.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aa6d40ab3a35e12ad5a5ed527ca767d0b265c284
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_read_write.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6f2c39ffaa4b7bd153b98d85cc98e29f6e4967b5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft_protocol.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft_protocol.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6e15672608d9a0a33fceb4efe66f822326a037f8
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_soft_protocol.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_strict.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_strict.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fdae5fba21cf38bd0bdaaf01a119a4029e342f1
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_strict.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b188c7eb0332bae859693f19fab62915ed8b6466
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_unix.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d540b4c5bb4ba904fd74ff664e67b726440b10a0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_util.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4fd94b5c0bc4ba28a1038bc9c60555b6dbe64dbf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/_windows.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/asyncio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/asyncio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6104e025cafc17c9e0e54299022567bc8bd03464
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/asyncio.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d5b207fec8f386a37306bb6c53d31498e9d12e8d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/__pycache__/version.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..3dbf52ccbeb70abc99e4f43b1e0f1cf039560bfc
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_api.py
@@ -0,0 +1,2266 @@
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "atexit",
+    "decimal",
+    "filelock._error",
+    "filelock._util",
+    "inspect",
+    "math",
+    "numbers",
+    "secrets",
+    "types",
+    "warnings",
+]
+
+import atexit
+import contextlib
+import inspect
+import logging
+import math
+import os
+import secrets
+import stat
+import sys
+import time
+import types
+import warnings
+from abc import ABCMeta, abstractmethod
+from collections.abc import Callable, Hashable
+from contextlib import contextmanager
+from dataclasses import dataclass, fields
+from decimal import Decimal
+from functools import cache, partial
+from itertools import count, starmap
+from numbers import Real
+from threading import TIMEOUT_MAX, Condition, RLock, Thread, current_thread, get_ident, local
+from typing import TYPE_CHECKING, Final, Generic, Literal, NoReturn, TypedDict, TypeVar, cast
+from weakref import WeakKeyDictionary, WeakValueDictionary, ref
+
+from filelock._error import SoftFileLockLifetimeWarning, Timeout
+from filelock._util import ensure_directory_exists
+
+#: No explicit file permission mode was passed. Lock files then open with 0o666 so umask and default ACLs pick
+#: the final permissions, and fchmod is skipped to preserve POSIX default ACL inheritance.
+_UNSET_FILE_MODE: Final[int] = -1
+
+_PERMISSION_BITS: Final[int] = stat.S_IRWXU | stat.S_IRWXG | stat.S_IRWXO
+
+#: Ceiling on the retry counter used as a power of two, so a long contended wait cannot overflow the backoff multiply.
+_MAX_BACKOFF_EXPONENT: Final[int] = 20
+
+#: How a context manager reconciles a body failure with a release failure on exit (see the property of this name).
+ContextErrorPolicy = Literal["chain", "group"]
+_CONTEXT_ERROR_POLICIES: Final[frozenset[str]] = frozenset({"chain", "group"})
+
+#: What a descriptor-owning backend does with an ``os.close`` failure after relinquishing ownership (see the property).
+CloseErrorPolicy = Literal["default", "raise", "suppress"]
+_CLOSE_ERROR_POLICIES: Final[frozenset[str]] = frozenset({"default", "raise", "suppress"})
+
+if TYPE_CHECKING:
+    from collections.abc import Generator, Mapping
+    from threading import Lock
+    from types import FrameType, TracebackType
+    from typing import Protocol
+
+    from _typeshed import Unused
+
+    from filelock._lease import _LeaseClaim
+    from filelock._read_write import ReadWriteLock
+    from filelock._soft_rw import SoftReadWriteLock
+
+    class _ForkResettable(Protocol):
+        def _reset_after_fork_in_child(self) -> None: ...
+
+    class _ForkDescriptorOwner(Protocol):
+        def _descriptors_for_fork(self) -> tuple[tuple[int, tuple[int, int] | None], ...]: ...
+
+    # Matched against the class object itself rather than `type[...]` of it. A metaclass supplies this method to the
+    # class while leaving instances without it, so a `type[_ForkResettableClass]` bound rejects `ReadWriteLock`.
+    class _ForkResettableClass(Protocol):
+        def _reset_class_after_fork(self) -> None: ...
+
+    class _RegisterAtFork(Protocol):
+        def __call__(
+            self,
+            *,
+            before: Callable[[], None] | None = None,
+            after_in_parent: Callable[[], None] | None = None,
+            after_in_child: Callable[[], None] | None = None,
+        ) -> None: ...
+
+    from typing import Self
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("filelock")
+_REGISTER_AT_FORK: Final[_RegisterAtFork | None] = cast("_RegisterAtFork | None", getattr(os, "register_at_fork", None))
+_HAS_REGISTER_AT_FORK: Final[bool] = _REGISTER_AT_FORK is not None
+
+_ExtraValue = TypeVar("_ExtraValue")
+_MarkerValue = TypeVar("_MarkerValue")
+_SubclassValue = TypeVar("_SubclassValue")
+_LockInitValue = float | int | bool | str | None | Callable[[int], None]
+
+
+class LockOptions(TypedDict, total=False):
+    """Every option the metaclass forwards, so a subclass adding its own can still type what it passes through."""
+
+    timeout: float
+    mode: int
+    thread_local: bool
+    blocking: bool
+    is_singleton: bool
+    poll_interval: float
+    lifetime: float | None
+    context_error_policy: ContextErrorPolicy
+    close_error_policy: CloseErrorPolicy
+    fallback_to_soft: bool
+    preserve_lock_file: bool
+    on_acquired: Callable[[int], None] | None
+
+
+def _is_exception_group(error: BaseException) -> bool:
+    return isinstance(error, BaseExceptionGroup)
+
+
+def _raise_grouped_errors(
+    message: str,
+    first_error: BaseException,
+    second_error: BaseException,
+    *additional_errors: BaseException,
+    marker: tuple[str, _MarkerValue] | None = None,
+) -> NoReturn:
+    errors = (first_error, second_error, *additional_errors)
+    _detach_grouped_contexts(errors)
+    group: Final = BaseExceptionGroup(message, errors)
+    if marker is not None:
+        setattr(group, marker[0], marker[1])
+    raise group from None
+
+
+def _detach_grouped_contexts(errors: tuple[BaseException, ...]) -> None:
+    seen: set[int] = set()
+    pending = list(errors)
+    while pending:
+        error = pending.pop()
+        if id(error) in seen:
+            continue
+        seen.add(id(error))
+        if (context := error.__context__) is not None and (
+            context is error
+            or _same_exception_tree(error, context)
+            or any(context is root or _contains_exception(root, context) for root in errors)
+        ):
+            error.__context__ = None
+        elif context is not None:
+            pending.append(context)
+        if error.__cause__ is not None:
+            pending.append(error.__cause__)
+        if _is_exception_group(error):
+            pending.extend(cast("_ExceptionGroupProtocol", error).exceptions)
+
+
+def _same_exception_tree(first: BaseException, second: BaseException) -> bool:
+    pending = [(first, second)]
+    seen: set[tuple[int, int]] = set()
+    while pending:
+        first_error, second_error = pending.pop()
+        if first_error is second_error:
+            continue
+        if (pair := (id(first_error), id(second_error))) in seen:
+            continue
+        seen.add(pair)
+        if (
+            type(first_error) is not type(second_error)
+            or not _is_exception_group(first_error)
+            or not _is_exception_group(second_error)
+        ):
+            return False
+        first_group = cast("_ExceptionGroupProtocol", first_error)
+        second_group = cast("_ExceptionGroupProtocol", second_error)
+        if first_group.message != second_group.message or len(first_group.exceptions) != len(second_group.exceptions):
+            return False
+        pending.extend(zip(first_group.exceptions, second_group.exceptions, strict=True))
+    return True
+
+
+def _contains_exception(error: BaseException, target: BaseException | None) -> bool:
+    if target is None or not _is_exception_group(error):
+        return False
+    pending = list(cast("_ExceptionGroupProtocol", error).exceptions)
+    seen: set[int] = set()
+    while pending:
+        child = pending.pop()
+        if child is target:
+            return True
+        if id(child) in seen:
+            continue
+        seen.add(id(child))
+        if _is_exception_group(child):
+            pending.extend(cast("_ExceptionGroupProtocol", child).exceptions)
+    return False
+
+
+def _append_exception_context(error: BaseException, context: BaseException) -> None:
+    if _exception_graph_contains(error, context) or _exception_graph_contains(context, error):
+        return
+    if error.__context__ is None:
+        error.__context__ = context
+        return
+    tail = error
+    seen: set[int] = set()
+    while id(tail) not in seen:
+        seen.add(id(tail))
+        if (next_error := tail.__cause__ if tail.__cause__ is not None else tail.__context__) is None:
+            tail.__context__ = context
+            return
+        tail = next_error
+
+
+def _exception_graph_contains(error: BaseException, target: BaseException) -> bool:
+    pending = [error]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if current is target:
+            return True
+        if id(current) in seen:  # pragma: no cover - arbitrary caller exceptions can contain cycles
+            continue
+        seen.add(id(current))
+        if current.__cause__ is not None:
+            pending.append(current.__cause__)
+        if current.__context__ is not None:
+            pending.append(current.__context__)
+        if _is_exception_group(current):
+            pending.extend(cast("_ExceptionGroupProtocol", current).exceptions)
+    return False
+
+
+def _grouped_errors(
+    error: BaseException, message: str, marker: tuple[str, _MarkerValue]
+) -> tuple[BaseException, ...] | None:
+    if not _is_exception_group(error):
+        return None
+    group = cast("_ExceptionGroupProtocol", error)
+    return group.exceptions if group.message == message and getattr(group, marker[0], None) is marker[1] else None
+
+
+if TYPE_CHECKING:
+
+    class _ExceptionGroupProtocol(Protocol):
+        @property
+        def message(self) -> str: ...
+
+        @property
+        def exceptions(self) -> tuple[BaseException, ...]: ...
+
+
+def _raise_chained_errors(first_error: BaseException, second_error: BaseException | None = None) -> NoReturn:
+    if second_error is None:
+        first_context = first_error.__context__
+        try:
+            raise first_error  # ruff:ignore[raise-within-try]  # the handler restores caller-supplied context before propagation
+        except BaseException:
+            first_error.__context__ = first_context
+            raise
+    if (second_context := second_error.__context__) is not None and second_context is not first_error:
+        _detach_exception_context(second_context, first_error)
+        _append_exception_context(first_error, second_context)
+    first_context = first_error.__context__
+    try:
+        raise first_error  # ruff:ignore[raise-within-try]  # the second raise needs this error as implicit context
+    except BaseException:  # ruff:ignore[blind-except]  # first_error may be a control-flow exception
+        first_error.__context__ = first_context
+        try:
+            raise second_error  # ruff:ignore[raise-within-try]  # the handler makes the chain interpreter-independent
+        except BaseException:
+            second_error.__context__ = first_error
+            first_error.__context__ = first_context
+            raise
+
+
+def _detach_exception_context(error: BaseException, target: BaseException) -> None:
+    pending = [error]
+    seen: set[int] = set()
+    while pending:
+        current = pending.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+        if current.__context__ is target:
+            current.__context__ = None
+        elif current.__context__ is not None:
+            pending.append(current.__context__)
+        if current.__cause__ is not None:
+            pending.append(current.__cause__)
+        if _is_exception_group(current):
+            pending.extend(cast("_ExceptionGroupProtocol", current).exceptions)
+
+
+def _raise_body_and_release(body_error: BaseException, release_error: BaseException) -> NoReturn:
+    # Group mode: surface the body failure and the release failure as sibling leaves instead of letting one hide in the
+    # other's __context__. BaseExceptionGroup returns a plain ExceptionGroup when both leaves subclass Exception, so
+    # ``except*`` and ``except Exception`` still catch them; a BaseException leaf (KeyboardInterrupt, CancelledError)
+    # keeps the group outside ordinary handlers. ``from None`` stops the group itself gaining a redundant __context__.
+    _raise_grouped_errors("lock body and release both failed", body_error, release_error)
+
+
+def _raise_cleanup_errors(
+    message: str,
+    primary_error: BaseException,
+    *cleanup_errors: BaseException | None,
+) -> NoReturn:
+    _raise_grouped_errors(
+        message,
+        primary_error,
+        *(error for error in cleanup_errors if error is not None),
+    )
+
+
+# On Windows os.path.realpath calls CreateFileW with share_mode=0, which blocks concurrent DeleteFileW and causes
+# livelocks under threaded contention with SoftFileLock. os.path.abspath is purely string-based and avoids this.
+_resolve_dir: Final[Callable[[str], str]] = os.path.abspath if sys.platform == "win32" else os.path.realpath
+
+
+def _canonical(path: str | os.PathLike[str]) -> str:
+    """
+    Return one stable key for *path*, collapsing equivalent spellings without following a final symlink.
+
+    Relative, absolute, and ``./`` spellings of one lock file must map to a single singleton instance, deadlock-registry
+    entry, and removal key. Resolving the whole path with ``realpath`` would follow a final symlink and alias a lock
+    target the backend deliberately rejects, so the registry identity would differ from the backend's. Resolving only
+    the parent directory and re-appending the literal final component collapses the equivalent spellings while keeping a
+    final symlink a distinct key. On Windows the parent is resolved with ``abspath`` so junctions and reparse points are
+    not followed either.
+    """
+    parent, name = os.path.split(os.fspath(path))
+    return os.path.join(_resolve_dir(parent or os.curdir), name)  # ruff:ignore[os-path-join]  # string join matches abspath/realpath
+
+
+class _ThreadLocalRegistry(local):
+    def __init__(self) -> None:
+        super().__init__()
+        self.held: dict[Hashable, int] = {}
+
+
+_registry: Final[_ThreadLocalRegistry] = _ThreadLocalRegistry()
+
+
+_T = TypeVar("_T", bound="BaseFileLock")
+_LockT = TypeVar("_LockT", bound="BaseFileLock | ReadWriteLock | SoftReadWriteLock")
+
+
+class FileLockMeta(ABCMeta):
+    _instances: WeakValueDictionary[str, BaseFileLock]
+    _instances_lock: RLock
+    _instances_under_construction: set[str]
+
+    def __call__(  # ruff:ignore[too-many-arguments]  # forwards the public constructor's documented parameters
+        cls: type[_T],
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = True,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+        **kwargs: _ExtraValue,
+    ) -> _T:
+        _ensure_current_process()
+        _resolve_lazy_imports_before_shutdown()
+        lifetime = _resolve_lifetime(lifetime, cls, stacklevel=cls._constructor_lifetime_warning_stacklevel)
+        poll_interval = _resolve_poll_interval(poll_interval)
+        # Validate before building the instance: a raise inside __init__ would leave a half-constructed object whose
+        # __del__ then trips over the missing context.
+        _check_blocking(blocking)
+        # nan is left to acquire, which knows whether the call blocks; a non-blocking call ignores the timeout.
+        timeout = _seconds("timeout", timeout)
+        _check_mode(mode, cls.__name__)
+        context_error_policy = _resolve_context_error_policy(context_error_policy)
+        close_error_policy = _resolve_close_error_policy(close_error_policy)
+        preserve_lock_file = _resolve_preserve_lock_file(
+            preserve=preserve_lock_file, supported=cls._preserve_lock_file_supported, cls_name=cls.__name__
+        )
+        on_acquired = _resolve_on_acquired(on_acquired, supported=cls._on_acquired_supported, cls_name=cls.__name__)
+        # Checked before the singleton lookup so a cache hit rejects a misspelled option just like a fresh build does.
+        params: Final = _supported_init_params(
+            cls,
+            {
+                "timeout": timeout,
+                "mode": mode,
+                "thread_local": thread_local,
+                "blocking": blocking,
+                "is_singleton": is_singleton,
+                "poll_interval": poll_interval,
+                "lifetime": lifetime,
+                "context_error_policy": context_error_policy,
+                "close_error_policy": close_error_policy,
+                "fallback_to_soft": fallback_to_soft,
+                "preserve_lock_file": preserve_lock_file,
+                "on_acquired": on_acquired,
+                **kwargs,
+            },
+        )
+        if not is_singleton:
+            return super().__call__(lock_file, **params)
+
+        # Look up, build and store under one lock. Without it two threads racing the first construction for a
+        # path both miss the cache and each build their own instance, so callers relying on is_singleton for
+        # reentrant locking across instances end up with two "singletons" and acquire()'s deadlock check then
+        # rejects a legitimate reentrant acquire; the unguarded writes to the WeakValueDictionary are a data
+        # race besides. ReadWriteLock and SoftReadWriteLock already guard their singleton caches this way.
+        # Key the cache on the canonical form so equivalent spellings of one path share a singleton, and it matches the
+        # deadlock-registry key acquire() uses.
+        singleton_key = _canonical(lock_file)
+        with cls._instances_lock:
+            # A cached lock resolves its relative path at each acquisition and pins it for the hold. After a chdir, or
+            # once a parent symlink points elsewhere, an unheld lock may name another file than this key; a held one
+            # names the file it pinned.
+            if (instance := cls._instances.get(singleton_key)) is None or _canonical(
+                instance._lock_path  # ruff:ignore[private-member-access]  # the metaclass owns the instance it returns
+            ) != singleton_key:
+                if singleton_key in cls._instances_under_construction:  # pragma: needs fork
+                    msg = f"Singleton lock construction is already active for {lock_file!s}"
+                    raise RuntimeError(msg)
+                construction_registry = cls._instances_under_construction
+                construction_pid = os.getpid()
+                construction_registry.add(singleton_key)
+                try:
+                    instance = super().__call__(lock_file, **params)
+                finally:
+                    construction_registry.discard(singleton_key)
+                if os.getpid() != construction_pid:  # pragma: needs fork
+                    msg = "Lock construction cannot continue after fork; construct a new lock in the child"
+                    raise RuntimeError(msg)
+                cls._instances[singleton_key] = instance
+                instance._singleton_key = singleton_key  # ruff:ignore[private-member-access]  # the cache entry the finalizer looks up
+                return instance
+
+        non_matching_params = {
+            name: (str(passed_param), str(set_param))
+            for name, (passed_param, set_param) in {
+                "thread_local": (thread_local, instance.is_thread_local()),
+                # Compare the wait, not the value: nan never equals itself, and -1, -5 and inf all mean no limit.
+                "timeout": (
+                    _timeout_behavior(timeout, any_negative=True),
+                    _timeout_behavior(instance.timeout, any_negative=True),
+                ),
+                "mode": (mode, instance._context.mode),  # ruff:ignore[private-member-access]  # compares against the managed instance's own context
+                "blocking": (blocking, instance.blocking),
+                "poll_interval": (poll_interval, instance.poll_interval),
+                "lifetime": (lifetime, instance.lifetime),
+                "context_error_policy": (context_error_policy, instance.context_error_policy),
+                "close_error_policy": (close_error_policy, instance.close_error_policy),
+                "fallback_to_soft": (fallback_to_soft, instance.fallback_to_soft),
+                "preserve_lock_file": (preserve_lock_file, instance.preserve_lock_file),
+            }.items()
+            if passed_param != set_param
+        }
+        # The metaclass owns the instance it returns, so reading the subclass hook stays inside this module's contract.
+        non_matching_params.update(instance._singleton_extra_mismatches(kwargs))  # ruff:ignore[private-member-access]
+        # Callables compare by identity, not equality: two equal callables can close over different state, so a
+        # singleton must reject a different hook object even if it compares equal. Keep it out of the scalar dict above.
+        hook_mismatch = on_acquired is not instance.on_acquired
+        if not non_matching_params and not hook_mismatch:
+            return instance  # ty: ignore[invalid-return-type]  # https://github.com/astral-sh/ty/issues/3231
+
+        msg = "Singleton lock instances cannot be initialized with differing arguments"
+        msg += "\nNon-matching arguments: "
+        for param_name, (passed_param, set_param) in non_matching_params.items():
+            msg += f"\n\t{param_name} (existing lock has {set_param} but {passed_param} was passed)"
+        if hook_mismatch:
+            msg += f"\n\ton_acquired (existing lock has {instance.on_acquired} but {on_acquired} was passed)"
+        raise ValueError(msg)
+
+
+def _resolve_lifetime(lifetime: float | None, cls: type[BaseFileLock], *, stacklevel: int) -> float | None:
+    """
+    Validate ``lifetime`` and drop a value the backend cannot honor.
+
+    ``lifetime`` is a deliberate age-based lease: a lock file older than ``lifetime`` is broken even while its holder is
+    still alive. Existence locks (:class:`SoftFileLock`) implement that behavior by unlinking a reclaimable pathname,
+    which can overlap a live holder. A native OS lock lives on the inode, so unlinking the pathname by age cannot revoke
+    the kernel lock; a contender would lock a fresh inode and overlap the live holder (#590). Ignore the request with a
+    warning rather than accept a setting that breaks mutual exclusion.
+    """
+    if lifetime is None:
+        return None
+    # An int stays exact: no float holds every int 4.0.12 accepted here.
+    if isinstance(lifetime, bool) or not isinstance(lifetime, int):
+        lifetime = _seconds("lifetime", lifetime)
+    if lifetime < 0 or (isinstance(lifetime, float) and not math.isfinite(lifetime)):
+        msg = f"lifetime must be finite and non-negative, not {lifetime!r}"
+        raise ValueError(msg)
+    if not cls._lifetime_supported:
+        warnings.warn(
+            f"lifetime is ignored for {cls.__name__}: {cls._lifetime_unsupported_reason}; "
+            f"only SoftFileLock supports lifetime-based expiry",
+            stacklevel=stacklevel,
+        )
+        return None
+    if cls._lifetime_replacements is not None:
+        strict_lock, lease = cls._lifetime_replacements
+        warnings.warn(
+            f"{cls.__name__}(lifetime=...) uses age-based expiry and can overlap a live holder; "
+            f"use {lease} for expiry or {strict_lock} for fail-closed locking",
+            SoftFileLockLifetimeWarning,
+            stacklevel=stacklevel,
+        )
+    return lifetime
+
+
+def _resolve_poll_interval(poll_interval: float) -> float:
+    """Validate ``poll_interval`` used for ``time.sleep`` / ``asyncio.sleep`` retries."""
+    if (poll_interval := _seconds("poll_interval", poll_interval)) < 0 or not math.isfinite(poll_interval):
+        msg = f"poll_interval must be finite and non-negative, not {poll_interval!r}"
+        raise ValueError(msg)
+    _check_timeout_max("poll_interval", poll_interval)
+    return poll_interval
+
+
+def _check_blocking(blocking: bool) -> None:  # ruff:ignore[boolean-type-hint-positional-argument]  # validates the option's own value
+    if not isinstance(blocking, bool):
+        msg = f"blocking must be a bool, not {type(blocking).__name__}"
+        raise TypeError(msg)
+
+
+def _seconds(name: str, value: float) -> float:
+    # 4.0.12 accepted Decimal and Fraction; a bool is a typo, and a string would only fail later.
+    if isinstance(value, bool) or not isinstance(value, (Real, Decimal)):
+        msg = f"{name} must be a number of seconds, not {type(value).__name__}"
+        raise TypeError(msg)
+    # float() refuses a signaling NaN, which means no number of seconds just as a quiet one does.
+    if isinstance(value, Decimal) and value.is_snan():
+        return math.nan
+    try:
+        seconds: Final = float(value)
+    except OverflowError:
+        msg = f"{name} is too large to be a number of seconds: {value!r}"
+        raise ValueError(msg) from None
+    # float() rounds a tiny negative to -0.0, which compares as zero, yet timeout and lifetime checks read the sign.
+    return -math.ulp(0.0) if seconds == 0 and value < 0 else seconds
+
+
+def _check_mode(mode: int, cls_name: str) -> None:
+    if mode == _UNSET_FILE_MODE:
+        return
+    if isinstance(mode, bool) or not isinstance(mode, int):
+        msg = f"mode must be an int, not {type(mode).__name__}"
+        raise TypeError(msg)
+    # A lock file is never executed, so setuid, setgid and sticky have no meaning on it and only widen its permissions.
+    if not 0 <= mode <= _PERMISSION_BITS:
+        msg = f"mode={mode:#o} must be within 0o000-0o777 for {cls_name}"
+        raise ValueError(msg)
+    # A lock reopens, reads, or deletes the files it creates, so a mode that denies the owner read or write fails later
+    # and for good.
+    if ~mode & (stat.S_IRUSR | stat.S_IWUSR):
+        msg = f"mode={mode:#o} must grant the owner read and write for {cls_name}"
+        raise ValueError(msg)
+
+
+def _resolve_context_error_policy(policy: str) -> ContextErrorPolicy:
+    if policy not in _CONTEXT_ERROR_POLICIES:
+        msg = f"context_error_policy must be 'chain' or 'group', got {policy!r}"
+        raise ValueError(msg)
+    return cast("ContextErrorPolicy", policy)
+
+
+def _resolve_close_error_policy(policy: str) -> CloseErrorPolicy:
+    if policy not in _CLOSE_ERROR_POLICIES:
+        msg = f"close_error_policy must be 'default', 'raise', or 'suppress', got {policy!r}"
+        raise ValueError(msg)
+    return cast("CloseErrorPolicy", policy)
+
+
+def _resolve_preserve_lock_file(*, preserve: bool, supported: bool, cls_name: str) -> bool:
+    # An existence lock unlinks its marker to release, so preserving the pathname would defeat unlocking. Reject the
+    # request rather than silently ignore it, since a caller asking for a stable identity must know it cannot be kept.
+    if preserve and not supported:
+        msg = f"preserve_lock_file=True is not supported by {cls_name}: unlinking its marker is how it releases"
+        raise ValueError(msg)
+    return preserve
+
+
+def _resolve_on_acquired(
+    on_acquired: Callable[[int], None] | None, *, supported: bool, cls_name: str
+) -> Callable[[int], None] | None:
+    if on_acquired is None:
+        return None
+    # An existence lock stores protocol state in its marker, so a caller writing through the descriptor would corrupt
+    # stale detection and ownership metadata; only native locks lend out the descriptor.
+    if not supported:
+        msg = f"on_acquired is not supported by {cls_name}: only native locks expose the lock descriptor"
+        raise ValueError(msg)
+    return on_acquired
+
+
+def _supported_init_params(
+    cls: type[BaseFileLock], params: dict[str, _LockInitValue | _ExtraValue]
+) -> dict[str, _LockInitValue | _ExtraValue]:
+    if (model := _init_parameter_model(cls)).accepts_kwargs:
+        return params
+    if unsupported := sorted(
+        name
+        for name, value in params.items()
+        if name not in model.accepted_params
+        and ((parameter := model.default_params.get(name)) is None or value != parameter.default)
+    ):
+        msg = f"{cls.__name__} does not support non-default lock options: {', '.join(unsupported)}"
+        raise TypeError(msg)
+    # virtualenv narrows a BaseFileLock descendant's signature; omit base defaults it does not accept (#340).
+    return {name: value for name, value in params.items() if name in model.accepted_params}
+
+
+def _timeout_behavior(timeout: float, *, any_negative: bool) -> float | str:
+    # inf, and for a BaseFileLock any negative value, wait without a limit like -1.
+    if math.isnan(timeout):
+        return "nan"
+    return -1.0 if timeout == math.inf or (any_negative and timeout < 0) else timeout
+
+
+def _check_timeout_max(name: str, value: float) -> None:
+    # Lock.acquire, Event.wait and time.sleep raise OverflowError past this bound, which is only ~49.7 days on Windows.
+    if value > TIMEOUT_MAX:
+        msg = f"{name} must not exceed threading.TIMEOUT_MAX ({TIMEOUT_MAX}), got {value!r}"
+        raise ValueError(msg)
+
+
+_INIT_PARAMETER_MODELS: Final[WeakKeyDictionary[type[BaseFileLock], _InitParameterModel]] = WeakKeyDictionary()
+
+
+def _init_parameter_model(cls: type[BaseFileLock]) -> _InitParameterModel:
+    # A strong cache would keep dynamically created subclasses alive for the process lifetime.
+    with _fork_transition(), _FORK_STATE.parameter_models_lock:
+        if (model := _INIT_PARAMETER_MODELS.get(cls)) is None:
+            parameters = inspect.signature(cls.__init__).parameters.values()
+            model = _InitParameterModel(
+                accepted_params=frozenset(
+                    parameter.name
+                    for parameter in parameters
+                    if parameter.kind in {inspect.Parameter.POSITIONAL_OR_KEYWORD, inspect.Parameter.KEYWORD_ONLY}
+                ),
+                accepts_kwargs=any(parameter.kind is inspect.Parameter.VAR_KEYWORD for parameter in parameters),
+                default_params={
+                    name: parameter
+                    for name, parameter in inspect.signature(type(cls).__call__).parameters.items()
+                    if parameter.default is not inspect.Parameter.empty
+                },
+            )
+            _INIT_PARAMETER_MODELS[cls] = model
+        return model
+
+
+@dataclass(frozen=True)
+class _InitParameterModel:
+    accepted_params: frozenset[str]
+    accepts_kwargs: bool
+    default_params: dict[str, inspect.Parameter]
+
+
+class BaseFileLock(contextlib.ContextDecorator, metaclass=FileLockMeta):  # ruff:ignore[too-many-public-methods]  # public config properties
+    """
+    Abstract base class for a file lock object.
+
+    Provides the common reentrant API and state management. Subclasses implement the locking mechanism
+    (:class:`UnixFileLock <filelock.UnixFileLock>`, :class:`WindowsFileLock <filelock.WindowsFileLock>`,
+    :class:`SoftFileLock <filelock.SoftFileLock>`).
+
+    """
+
+    _instances: WeakValueDictionary[str, BaseFileLock]
+    _instances_lock: RLock
+    _instances_under_construction: set[str]
+
+    #: How the cross-instance deadlock message names the conflicting holder; the async subclass says "task".
+    _deadlock_holder_desc: str = "FileLock instance in this thread"
+
+    #: Whether an age-based :attr:`lifetime` lease may break this lock. Only existence locks set it (they reclaim by
+    #: unlinking a pathname); native OS locks leave it ``False`` since a kernel lock cannot be revoked by file age.
+    _lifetime_supported: bool = False
+
+    #: Strict-lock and lease replacements for a backend with legacy age-based expiry.
+    _lifetime_replacements: tuple[str, str] | None = None
+
+    #: Why a backend that refuses ``lifetime`` cannot honor it, named in the warning that drops the value.
+    _lifetime_unsupported_reason: str = "a native OS lock cannot be broken safely by file age"
+
+    #: Async construction adds one metaclass frame before lifetime validation.
+    _constructor_lifetime_warning_stacklevel: int = 3
+
+    #: Whether :attr:`preserve_lock_file` may be ``True``. Native locks keep the pathname on release, so they support
+    #: it; existence locks unlink their marker to release and reject it.
+    _preserve_lock_file_supported: bool = True
+
+    #: Whether an :attr:`on_acquired` hook may be set. Native locks lend the descriptor out; existence locks keep
+    #: protocol state in the marker and reject it.
+    _on_acquired_supported: bool = True
+
+    #: Ceiling in seconds on the jittered backoff between contended acquisition retries. ``0`` keeps the fixed
+    #: poll cadence; a multi-file backend sets it so contending processes desynchronize instead of livelocking.
+    _poll_backoff_cap: float = 0.0
+
+    #: The singleton cache key of this instance, or ``None`` outside the cache.
+    _singleton_key: str | None = None
+
+    def __init_subclass__(cls, **kwargs: _SubclassValue) -> None:
+        """Give each lock subclass its own singleton registry and lock."""
+        super().__init_subclass__(**kwargs)
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = RLock()
+        cls._instances_under_construction = set()
+        _register_fork_class(cls)
+
+    @classmethod
+    def _reset_class_after_fork(cls) -> None:  # pragma: forked child
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = RLock()
+        cls._instances_under_construction = set()
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = True,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+    ) -> None:
+        """
+        Create a new lock object.
+
+        :param lock_file: path to the file
+        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in the
+            acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it to a
+            negative value or ``inf``. A timeout of 0 means that there is exactly one attempt to acquire the file lock.
+        :param mode: file permissions for the lockfile. When not specified, the OS controls permissions via umask and
+            default ACLs, preserving POSIX default ACL inheritance in shared directories. Construction raises
+            :class:`ValueError` unless it grants the owner read and write, which the lock needs for its own files. On
+            Windows a native lock creates its file with an owner-only ACL when the mode has no group and other bits; any
+            other mode, and a soft lock, leave the file the ACL its directory hands down. A Unix lock file that already
+            exists keeps its permissions.
+        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to
+            ``False`` then the lock will be reentrant across threads. When ``True`` (the default), **all fields of the
+            lock's internal context are per-thread**, including the configuration values ``poll_interval``, ``timeout``,
+            ``blocking``, ``mode``, and ``lifetime``. Setting one of these properties from one thread does not change
+            the value seen by another thread; threads that did not perform the write continue to see the value supplied
+            at construction time. ``mode`` has no setter, so construction is the only place it is ever set. If you need
+            configuration values to be visible across threads, construct the lock with ``thread_local=False``.
+        :param blocking: whether the lock should be blocking or not
+        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created per lock
+            file. This is useful if you want to use the lock object for reentrant locking without needing to pass the
+            same object around.
+        :param poll_interval: default interval for polling the lock file, in seconds. It will be used as fallback value
+            in the acquire method, if no poll_interval value (``None``) is given.
+        :param lifetime: for :class:`SoftFileLock`, the age in seconds after which a waiting process may delete the
+            marker, even while its holder remains alive. This legacy expiry mode does not provide strict mutual
+            exclusion. ``None`` (the default) disables age-based expiry. Native OS locks (:class:`FileLock`) cannot be
+            revoked by file age and ignore a non-``None`` ``lifetime`` with a warning.
+        :param context_error_policy: how a context manager reconciles a failure in its body with a failure while
+            releasing on exit. ``"chain"`` (the default) keeps Python's behavior: the release error propagates with the
+            body error in its ``__context__``. ``"group"`` raises a :class:`BaseExceptionGroup` holding the body error
+            first and the release error second, so neither hides the other.
+        :param close_error_policy: what to do with an ``os.close`` failure after relinquishing descriptor ownership.
+            ``"default"`` keeps each backend's historical behavior (Unix native locks drop a FUSE/Docker ``EIO``;
+            Windows native locks and :class:`SoftFileLock` propagate); ``"raise"`` always propagates the ``OSError``;
+            ``"suppress"`` always ignores it. Held state is released either way. It does not affect unlock failures or
+            lock-file deletion.
+        :param fallback_to_soft: for :class:`UnixFileLock`, whether to switch to :class:`SoftFileLock` when the
+            filesystem's ``flock`` returns ``ENOSYS``. ``True`` (the default) keeps the historical fallback;
+            ``False`` fails closed, letting the ``ENOSYS`` propagate so a caller that needs kernel-enforced
+            locking is never silently downgraded. It has no effect on Windows or :class:`SoftFileLock`.
+        :param preserve_lock_file: for native locks (:class:`FileLock`), whether filelock promises not to unlink the
+            lock pathname on release. ``False`` (the default) keeps each backend's cleanup: Windows removes the lock
+            file, Unix already leaves it. ``True`` keeps a stable file identity for ACLs, auditing, and holder metadata:
+            Windows skips its post-release unlink and Unix refuses to enter the ``ENOSYS`` soft fallback (which releases
+            by unlinking). :class:`SoftFileLock` rejects ``True``. The promise covers filelock's own release path only;
+            it cannot stop another process or the filesystem from removing the pathname.
+        :param on_acquired: for native locks (:class:`FileLock`), a callable invoked with the borrowed lock descriptor
+            once per physical acquisition, after filelock holds the native lock and finished backend initialization but
+            before :meth:`~BaseFileLock.acquire` returns. Recursive acquisitions do not call it again. The callback may
+            read, write, seek, truncate, or set metadata through ``os`` on the descriptor, but must not close, unlock,
+            or take ownership of it, and filelock does not fsync its writes. If it raises, filelock releases the lock
+            and re-raises. :class:`SoftFileLock` rejects the hook.
+
+        :raises TypeError: if *timeout* or *poll_interval* is a :class:`bool` or not a real number, *blocking* is not a
+            :class:`bool`, or *mode* is not an :class:`int`
+        :raises ValueError: if *poll_interval* is negative, not finite, or above :data:`threading.TIMEOUT_MAX`, if
+            *timeout* is too large to convert to :class:`float`, or if *mode* falls outside ``0o000``-``0o777`` or
+            denies the owner read and write
+
+        """
+        self._creator_pid = os.getpid()
+        #: Holder id in the deadlock registry; a stand-in that finishes the finalizer has another id(self).
+        self._holder_id = id(self)
+        self._transition_lock = RLock()
+        self._is_thread_local = thread_local
+        self._is_singleton = is_singleton
+        self._context_error_policy = context_error_policy  # already validated by the metaclass
+        self._close_error_policy = close_error_policy  # already validated by the metaclass
+        self._fallback_to_soft = fallback_to_soft
+        self._preserve_lock_file = preserve_lock_file  # already validated by the metaclass
+        self._on_acquired = on_acquired  # already validated by the metaclass
+
+        self._context: FileLockContext = (ThreadLocalFileContext if thread_local else FileLockContext)(
+            lock_file=os.fspath(lock_file),
+            timeout=timeout,
+            mode=mode,
+            blocking=blocking,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+        )
+        #: Each thread's committed hold on a thread-local lock, so another thread can release it.
+        self._thread_holds: dict[int, tuple[FileLockContext, Thread]] = {}
+        #: Each thread's uncommitted acquisition, so a backend can finish it for an exited thread.
+        self._thread_pending: dict[int, tuple[FileLockContext, Thread]] = {}
+        _register_fork_object(self)
+
+    def _singleton_extra_mismatches(  # ruff:ignore[no-self-use]  # the base class adds no options of its own
+        self, _kwargs: Mapping[str, _ExtraValue], /
+    ) -> dict[str, tuple[str, str]]:
+        # A subclass's own options reach the metaclass only as kwargs, and only the subclass knows their defaults and
+        # how __init__ resolves them, so each override compares its options and merges what super() reports.
+        return {}
+
+    def is_thread_local(self) -> bool:
+        """:returns: a flag indicating if this lock is thread local or not"""
+        return self._is_thread_local
+
+    @property
+    def is_singleton(self) -> bool:
+        """
+        A flag indicating if this lock is singleton or not.
+
+        .. versionadded:: 3.13.0
+
+        """
+        return self._is_singleton
+
+    @property
+    def context_error_policy(self) -> ContextErrorPolicy:
+        """
+        How a context manager reconciles a body failure with a release failure on exit.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._context_error_policy
+
+    @property
+    def close_error_policy(self) -> CloseErrorPolicy:
+        """
+        What a lock does with an ``os.close`` failure after relinquishing descriptor ownership.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._close_error_policy
+
+    def _close_released_fd(self, fd: int, *, default_suppresses: bool) -> None:
+        # CPython never retries close() after EINTR because the descriptor number may already be reused, so neither does
+        # this. close_error_policy decides the error's fate after the backend relinquishes descriptor ownership.
+        try:
+            os.close(fd)
+        except OSError:
+            if not self._suppresses_close_error(default_suppresses=default_suppresses):
+                raise
+
+    def _suppresses_close_error(self, *, default_suppresses: bool) -> bool:
+        return self._close_error_policy == "suppress" or (self._close_error_policy == "default" and default_suppresses)
+
+    @property
+    def fallback_to_soft(self) -> bool:
+        """
+        Whether a :class:`FileLock` falls back to :class:`SoftFileLock` when the filesystem lacks ``flock``.
+
+        Only :class:`UnixFileLock` acts on it: when ``False`` an ``ENOSYS`` from ``flock`` propagates instead of
+        switching to existence-lock semantics.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._fallback_to_soft
+
+    @property
+    def preserve_lock_file(self) -> bool:
+        """
+        Whether filelock promises not to unlink the lock pathname on release.
+
+        When ``True``, Windows skips its post-release unlink and Unix refuses the ``ENOSYS`` soft fallback.
+        :class:`SoftFileLock` rejects ``True`` because unlinking its marker is how it releases.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._preserve_lock_file
+
+    @property
+    def on_acquired(self) -> Callable[[int], None] | None:
+        """
+        The callback run with the borrowed lock descriptor once per physical acquisition, or ``None``.
+
+        Native locks only. It runs after the native lock is held and backend initialization finished, before
+        :meth:`~BaseFileLock.acquire` returns; a raise rolls back the acquisition. :class:`SoftFileLock` rejects it.
+
+        .. versionadded:: 3.30.0
+
+        """
+        return self._on_acquired
+
+    @property
+    def lock_file(self) -> str:
+        """Path to the lock file."""
+        return self._context.lock_file
+
+    @property
+    def _lock_path(self) -> str:
+        # The OS resolves a relative lock_file against the working directory at each call. A chdir during an
+        # acquisition or a hold would otherwise make the backend wait on, lock or remove a different file.
+        return self._context.claim_root or self._context.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """
+        The default timeout value, in seconds.
+
+        .. versionadded:: 2.0.0
+
+        """
+        return self._context.timeout
+
+    @timeout.setter
+    def timeout(self, value: float | str | bytes | bytearray) -> None:
+        """
+        Change the default timeout value.
+
+        :param value: the new value, in seconds; a negative value or ``inf`` waits without a limit
+
+        :raises TypeError: if *value* is a :class:`bool` or not a real number
+        :raises ValueError: if *value* is too large to convert to :class:`float`
+
+        .. deprecated:: 4.0.13
+
+            Passing a numeric string; pass the number instead.
+
+        """
+        if isinstance(value, (str, bytes, bytearray)):
+            warnings.warn(
+                "setting timeout from a string is deprecated and will be removed; pass a number",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            value = float(value)
+        self._context.timeout = _seconds("timeout", value)
+
+    @property
+    def blocking(self) -> bool:
+        """
+        Whether the locking is blocking or not.
+
+        .. versionadded:: 3.14.0
+
+        """
+        return self._context.blocking
+
+    @blocking.setter
+    def blocking(self, value: bool) -> None:
+        """
+        Change the default blocking value.
+
+        :param value: the new value as bool
+
+        :raises TypeError: if *value* is not a bool
+
+        """
+        _check_blocking(value)
+        self._context.blocking = value
+
+    @property
+    def poll_interval(self) -> float:
+        """
+        The default polling interval, in seconds.
+
+        .. versionadded:: 3.24.0
+
+        """
+        return self._context.poll_interval
+
+    @poll_interval.setter
+    def poll_interval(self, value: float) -> None:
+        """
+        Change the default polling interval.
+
+        :param value: the new value, in seconds
+
+        :raises ValueError: if *value* is negative, not finite, or above :data:`threading.TIMEOUT_MAX`
+        :raises TypeError: if *value* is a :class:`bool` or not a real number
+
+        """
+        self._context.poll_interval = _resolve_poll_interval(value)
+
+    @property
+    def lifetime(self) -> float | None:
+        """
+        The soft marker age in seconds that permits expiry, or ``None`` to disable age-based expiry.
+
+        A non-``None`` value permits a waiter to enter while the previous holder remains active, so it does not provide
+        strict mutual exclusion. Native locks ignore the value with a warning.
+
+        .. versionadded:: 3.24.0
+
+        """
+        return self._context.lifetime
+
+    @lifetime.setter
+    def lifetime(self, value: float | None) -> None:
+        """
+        Change the legacy age-based expiry threshold.
+
+        :param value: the new value in seconds, or ``None`` to disable expiration
+
+        :raises ValueError: if *value* is negative or not finite
+        :raises TypeError: if *value* is not ``None`` and not a real number
+
+        """
+        self._context.lifetime = _resolve_lifetime(value, type(self), stacklevel=3)
+
+    @property
+    def mode(self) -> int:
+        """
+        The file permissions requested for the lock file.
+
+        Without an explicit ``mode`` this reports ``0o644`` for backwards compatibility, but the file is created with
+        ``0o666`` filtered through the umask and default ACLs, so with a ``002`` umask it ends up ``0o664``. Check
+        :attr:`has_explicit_mode` before relying on the value, or ``os.stat`` the file for its actual permissions.
+
+        """
+        return 0o644 if self._context.mode == _UNSET_FILE_MODE else self._context.mode
+
+    @property
+    def has_explicit_mode(self) -> bool:
+        """Whether the file permissions were explicitly set."""
+        return self._context.mode != _UNSET_FILE_MODE
+
+    def _open_mode(self) -> int:
+        """Mode for ``os.open``: 0o666 when unset so umask and ACLs decide, otherwise the explicit mode."""
+        return 0o666 if self._context.mode == _UNSET_FILE_MODE else self._context.mode
+
+    @property
+    def is_locked(self) -> bool:
+        """
+        A boolean indicating if the lock file is holding the lock currently.
+
+        .. versionchanged:: 2.0.0
+
+            This was previously a method and is now a property.
+
+        """
+        _ensure_current_process()
+        return self._context.lock_file_fd is not None
+
+    @property
+    def lock_counter(self) -> int:
+        """The number of times this lock has been acquired (but not yet released)."""
+        _ensure_current_process()
+        return self._context.lock_counter
+
+    def __enter__(self) -> Self:
+        """
+        Acquire the lock.
+
+        :returns: the lock object
+
+        """
+        self.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Release the lock, reconciling a release failure with any body failure per :attr:`context_error_policy`."""
+        self._release_in_context(exc_value)
+
+    def _release_in_context(self, body_error: BaseException | None) -> None:
+        # Release from a context-manager exit. "chain" lets a release failure propagate with the body error already in
+        # its __context__ (Python's default); "group" raises both as sibling leaves so neither one hides the other.
+        try:
+            self.release()
+        except BaseException as release_error:
+            if body_error is None or self._context_error_policy == "chain":
+                raise
+            _raise_body_and_release(body_error, release_error)
+
+    def __del__(self) -> None:
+        """Force-release so a dropped reference never leaks a held lock, including every thread's hold."""
+        if vars(self).get("_creator_pid") != os.getpid():
+            return  # pragma: forked child
+        # CPython runs __del__ before it clears weak references. Until then the singleton cache still hands this lock
+        # out, and a thread that takes a hold through it would lose that hold to a release here. The cycle collector
+        # clears the references first, and at exit no other thread runs.
+        if (key := self._singleton_key) is not None and not sys.is_finalizing() and self._instances.get(key) is self:
+            self._release_once_unreachable()
+        else:
+            self._release_abandoned_holds()
+
+    def _release_abandoned_holds(self) -> None:
+        # A finalizer must not raise. A release error during garbage collection would otherwise surface as an
+        # unraisable-exception warning, attributed to whichever code triggered collection. The dropped lock still gets
+        # best-effort cleanup; an explicit release() reports the same error to a caller who can act on it.
+        with contextlib.suppress(Exception):
+            self.release(force=True)
+        # Nothing references the lock any more, so no thread can still be inside it through this instance.
+        with contextlib.suppress(Exception):
+            self._release_thread_holds(exited_only=False)
+
+    def _release_once_unreachable(self) -> None:
+        # The callback runs once the lock is gone, so it reads the state through a holder. The state alone keeps the
+        # holder alive: a reference from the callback would keep the state, and through it the lock, alive.
+        self._finalizer_state = _FinalizerState(vars(self))
+        _UNREACHABLE_LOCKS.add(ref(self, partial(_finalize_unreachable, ref(self._finalizer_state), type(self))))
+
+    def acquire(
+        self,
+        timeout: float | None = None,
+        poll_interval: float | None = None,
+        *,
+        poll_intervall: float | None = None,
+        blocking: bool | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AcquireReturnProxy[Self]:
+        """
+        Try to acquire the file lock.
+
+        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default :attr:`~timeout` is and
+            if ``timeout < 0``, there is no timeout and this method will block until the lock could be acquired
+        :param poll_interval: interval of trying to acquire the lock file, ``None`` means use the default
+            :attr:`~poll_interval`
+        :param poll_intervall: deprecated, kept for backwards compatibility, use ``poll_interval`` instead
+        :param blocking: whether to retry until this call holds the lock or the timeout expires, ``None`` means use
+            the default :attr:`~blocking`. ``False`` makes one attempt and raises :class:`~Timeout` on failure.
+        :param cancel_check: a callable returning ``True`` when the acquisition should be canceled. Checked on each poll
+            iteration. When triggered, raises :class:`~Timeout` just like an expired timeout.
+
+        :returns: a context object that will unlock the file when the context is exited
+
+        :raises Timeout: if fails to acquire lock within the timeout period
+        :raises ValueError: if a blocking call gets a ``nan`` timeout, or *poll_interval* exceeds
+            :data:`threading.TIMEOUT_MAX`
+
+        .. code-block:: python
+
+            # You can use this method in the context manager (recommended)
+            with lock.acquire():
+                pass
+
+            # Or use an equivalent try-finally construct:
+            lock.acquire()
+            try:
+                pass
+            finally:
+                lock.release()
+
+        .. versionchanged:: 2.0.0
+
+            This method returns now a *proxy* object instead of *self*, so that it can be used in a with statement
+            without side effects.
+
+        """
+        self._raise_if_inherited()
+        if timeout is None:
+            timeout = self._context.timeout
+
+        if blocking is None:
+            blocking = self._context.blocking
+
+        if poll_intervall is not None:
+            msg = "use poll_interval instead of poll_intervall"
+            warnings.warn(msg, DeprecationWarning, stacklevel=2)
+            poll_interval = poll_intervall
+
+        poll_interval = poll_interval if poll_interval is not None else self._context.poll_interval
+        poll_interval = _resolve_poll_interval(poll_interval)
+        timeout = _resolve_timeout(timeout, blocking=blocking)
+
+        start_time = time.perf_counter()
+        # Wait for admission before touching any state: a caller refused entry must leave the counter, the registry and
+        # the descriptor exactly as it found them.
+        with self._transition_admission(
+            blocking=blocking,
+            cancel_check=cancel_check,
+            timeout=timeout,
+            poll_interval=poll_interval,
+            start_time=start_time,
+        ):
+            # The interrupted acquire cannot run until the handler returns, so a second one here would wait on it
+            # forever or take the lock out from under it. Once the lock is held, as in an on_acquired hook, it nests.
+            if not self.is_locked and _on_this_stack(self._context.acquiring):
+                msg = f"Deadlock: lock '{self.lock_file}' is acquired again while this thread's acquire of it waits"
+                raise RuntimeError(msg)
+            # An interrupted release commits only the hold it started with and ignores a release above it on the
+            # stack. A hold taken here would nest into one the OS dropped, or stay held for good.
+            if _on_this_stack(self._context.releasing):
+                msg = f"lock '{self.lock_file}' is acquired again while this thread's release of it runs"
+                raise RuntimeError(msg)
+            canonical = _canonical(self.lock_file)
+            self._context.lock_counter += 1
+
+            self._raise_if_would_deadlock(canonical, timeout=timeout, blocking=blocking)
+            if not self.is_locked:
+                self._pin_lock_path(canonical)
+
+            try:
+                self._poll_until_acquired(
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    timeout=timeout,
+                    poll_interval=poll_interval,
+                    start_time=start_time,
+                )
+            except BaseException:
+                self._reconcile_failed_acquire(canonical)
+                raise
+            self._commit_acquire(canonical)
+            return AcquireReturnProxy(lock=self)
+
+    @contextlib.contextmanager
+    def _transition_admission(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> Generator[None]:
+        # One thread at a time drives the physical transition of a shared instance: its counter, descriptor and claim
+        # state are plain attributes every thread reads and writes, so an unserialized loser clears the winner's
+        # descriptor or double-closes it. Waiting in slices keeps cancel_check and the timeout live. A thread-local
+        # context is never shared, so it skips the gate.
+        if self._is_thread_local:
+            yield
+            return
+        deadline: Final = None if timeout < 0 else start_time + timeout
+        wait: Final = poll_interval if blocking else 0.0
+        # wait leads the min() so a non-blocking call, whose nan timeout goes unchecked, waits 0 rather than nan.
+        while not self._transition_lock.acquire(
+            timeout=wait if deadline is None else min(wait, max(deadline - time.perf_counter(), 0.0))
+        ):
+            if not blocking or (cancel_check is not None and cancel_check()):
+                raise Timeout(self.lock_file)
+            if deadline is not None and time.perf_counter() >= deadline:
+                raise Timeout(self.lock_file)
+        try:
+            yield
+        finally:
+            self._transition_lock.release()
+
+    def release(self, force: bool = False) -> None:  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        """
+        Release the file lock. The lock is only completely released when the lock counter reaches 0. The lock file
+        itself may be deleted automatically, the behavior is platform-specific.
+
+        :param force: If true, the lock counter is ignored and the lock is released in every case. On a thread-local
+            lock it also releases the holds of threads that exited without releasing; a hold of a thread still running
+            stays with that thread. Dropping the last reference to the lock releases every thread's hold.
+
+        """
+        counter_before: int | None = None
+        try:
+            counter_before = self._context.lock_counter
+            self._release_current(force=force)
+        except BaseException as release_error:
+            # A handler that raised after release() began and before the backend changed anything leaves the counter as
+            # it was; only then does a second attempt release the hold the caller gave up. A failed system call keeps it
+            # for an explicit retry, and a changed counter means a nested level or the backend's own retry already ran.
+            if (
+                counter_before is not None
+                and counter_before == self._context.lock_counter
+                and self._context.lock_file_fd is not None
+                and not _is_system_call_failure(release_error)
+            ):
+                with contextlib.suppress(Exception):
+                    self._release_current(force=force)
+            raise
+        if force:
+            self._release_thread_holds(exited_only=True)
+
+    def _release_current(self, *, force: bool) -> None:
+        # A shared instance releases under the same gate its acquisition ran through, so a thread entering the lock
+        # never observes a partially torn-down owner. Only an acquirer that found the lock free holds the gate for
+        # long, so an unheld lock returns without waiting behind it.
+        if self._context.lock_file_fd is None:
+            # Only a committed hold registers, so an entry without a descriptor is a release a signal handler stopped
+            # after the unlock; left alone it refuses every other instance on this path in this thread.
+            if self._context.lock_file_registry is not None:
+                self._finish_interrupted_release()
+            return
+        with contextlib.nullcontext() if self._is_thread_local else self._transition_lock:
+            state: Final = self._hold_state()
+            # A signal handler can land between the backend's unlock and its clearing of the descriptor, where a second
+            # release would close the number twice, maybe hitting a file that reused it. The flag holds the releasing
+            # frame, so only a release still on this stack stops it, and a flag a cut-short frame left set does not.
+            if self._creator_pid != os.getpid() or state.lock_file_fd is None or _on_this_stack(state.releasing):
+                return
+            if not force and state.lock_counter > 1:
+                state.lock_counter -= 1
+                return
+            state.releasing = inspect.currentframe()
+            try:
+                _LOGGER.debug("Attempting to release lock %s on %s", id(self), self.lock_file)
+                self._release_with_fork_tracking()
+            finally:
+                # A failure after the OS unlock (during close or unlink) still released the lock: the backend cleared
+                # its descriptor, so commit the counter and registry to released even as the cleanup error propagates.
+                # A failure that left the lock held keeps the counter so a later release can retry the OS unlock.
+                if state.lock_file_fd is None:  # pragma: no branch  # a release that returns cleared the descriptor
+                    self._commit_release()
+                state.releasing = None
+            _LOGGER.debug("Lock %s released on %s", id(self), self.lock_file)
+
+    def _finish_interrupted_release(self) -> None:
+        # An unheld lock never waits behind an acquirer, whose own commit takes the entry over anyway.
+        if not self._transition_lock.acquire(blocking=False):
+            return  # pragma: no cover  # only a concurrent acquire of a shared instance holds the gate
+        try:
+            if self._context.lock_file_fd is None:  # pragma: no branch  # only a racing acquire fills it
+                self._commit_release()
+        finally:
+            self._transition_lock.release()
+
+    def _hold_state(self) -> FileLockContext:
+        return self._context.current if isinstance(self._context, ThreadLocalFileContext) else self._context
+
+    def _release_thread_holds(self, *, exited_only: bool) -> None:
+        if not isinstance(context := self._context, ThreadLocalFileContext):
+            return
+        # Serialized, or two threads would both close an exited thread's descriptor; copy() is atomic free-threaded.
+        with self._transition_lock:
+            own: Final = context.current
+            for held, thread in self._thread_holds.copy().values():
+                if exited_only and thread.is_alive():
+                    continue
+                context.current = held
+                try:
+                    self._release_current(force=True)
+                finally:
+                    context.current = own
+
+    def _raise_if_inherited(self) -> None:
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            msg = f"{type(self).__name__} on {self.lock_file} was inherited across fork; construct a new instance"
+            raise RuntimeError(msg)
+
+    def _mark_descriptor_owned(self, fd: int, identity: tuple[int, int] | None = None) -> None:
+        state: Final = self._hold_state()
+        # Held first, pending cleared second: an interrupt between the two then leaves the descriptor recorded.
+        state.lock_file_fd = fd
+        state.lock_file_fd_identity = identity
+        state.pending_lock_file_fd = None
+        state.pending_lock_file_fd_identity = None
+        if isinstance(self._context, ThreadLocalFileContext):
+            self._thread_pending.pop(id(state), None)
+            self._thread_holds[id(state)] = state, current_thread()
+
+    def _mark_descriptor_pending(self, fd: int, identity: tuple[int, int] | None = None) -> None:
+        state: Final = self._hold_state()
+        state.pending_lock_file_fd = fd
+        state.pending_lock_file_fd_identity = identity
+        if isinstance(self._context, ThreadLocalFileContext):
+            self._thread_pending[id(state)] = state, current_thread()
+
+    def _mark_descriptor_released(self) -> None:
+        state: Final = self._hold_state()
+        state.pending_lock_file_fd = None
+        state.pending_lock_file_fd_identity = None
+        state.lock_file_fd = None
+        state.lock_file_fd_identity = None
+        if isinstance(self._context, ThreadLocalFileContext):
+            self._thread_pending.pop(id(state), None)
+            self._thread_holds.pop(id(state), None)
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        # fork copies the lock in whatever state the parent's threads left it, so give the child an unheld one.
+        self._transition_lock = RLock()
+        if isinstance(self._context, ThreadLocalFileContext):
+            self._thread_holds.clear()
+            self._thread_pending.clear()
+        self._context.owner_claim_paths = ()
+        self._context.claim_root = None
+        self._context.lock_file_fd = None
+        self._context.lock_file_fd_token = None
+        self._context.lock_file_fd_identity = None
+        self._context.pending_lock_file_fd = None
+        self._context.pending_lock_file_fd_identity = None
+        self._context.lock_counter = 0
+        self._context.releasing = None
+        self._context.acquiring = None
+        self._context.lock_file_key = None
+        self._context.lock_file_registry = None
+
+    def _descriptors_for_fork(self) -> tuple[tuple[int, tuple[int, int] | None], ...]:  # pragma: needs fork
+        descriptors: list[tuple[int, tuple[int, int] | None]] = []
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:
+            descriptors.append((self._context.lock_file_fd, self._context.lock_file_fd_identity))
+        if self._context.pending_lock_file_fd is not None:
+            descriptors.append((self._context.pending_lock_file_fd, self._context.pending_lock_file_fd_identity))
+        return tuple(descriptors)
+
+    def _raise_if_would_deadlock(self, canonical: str, *, timeout: float, blocking: bool) -> None:
+        """
+        Fail fast when a *different* live instance already holds this path in the current deadlock scope.
+
+        Only the first, indefinitely-blocking acquire can self-deadlock this way: waiting in the OS primitive would
+        block on a lock this flow already owns. A finite timeout or ``blocking=False`` keeps the normal Timeout path.
+        """
+        would_block = self._context.lock_counter == 1 and not self.is_locked and timeout < 0 and blocking
+        if would_block and _registry.held.get(self._registry_key(canonical)) not in {None, self._holder_id}:
+            self._context.lock_counter -= 1
+            msg = (
+                f"Deadlock: lock '{self.lock_file}' is already held by a different {self._deadlock_holder_desc}. "
+                f"Use is_singleton=True to enable reentrant locking across instances."
+            )
+            raise RuntimeError(msg)
+
+    def _registry_key(self, canonical: str) -> Hashable:
+        return canonical if (scope := self._deadlock_scope()) is None else (scope, canonical)
+
+    @staticmethod
+    def _deadlock_scope() -> Hashable | None:
+        """
+        Execution unit whose own hold would deadlock a new acquire.
+
+        ``None`` scopes holders to the thread, which the thread-local registry already separates. Async locks
+        override it with the running task, since one event loop thread runs many tasks and only a reacquire from
+        the *same* task can self-deadlock.
+        """
+        return None
+
+    def _poll_until_acquired(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> None:
+        lock_id = id(self)
+        lock_filename = self.lock_file
+        attempt = 0
+        self._context.acquiring = inspect.currentframe()
+        try:
+            # Created once, so a directory that disappears while the acquisition waits fails it, not builds a second
+            # lock file beside the holder's.
+            ensure_directory_exists(self._lock_path)
+            while True:
+                self._raise_if_inherited()
+                if not self.is_locked:
+                    self._try_break_expired_lock()
+                    _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename)
+                    self._acquire_with_fork_tracking()
+                    self._raise_if_inherited()
+                if self.is_locked:
+                    _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename)
+                    return
+                if self._check_give_up(
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    timeout=timeout,
+                    start_time=start_time,
+                ):
+                    raise Timeout(lock_filename, self._unprobeable_holder())
+                attempt += 1
+                delay = self._poll_delay(poll_interval, attempt)
+                if timeout >= 0:
+                    delay = min(delay, max(start_time + timeout - time.perf_counter(), 0.0))
+                msg = "Lock %s not acquired on %s, waiting %s seconds ..."
+                _LOGGER.debug(msg, lock_id, lock_filename, delay)
+                time.sleep(delay)
+        finally:
+            self._context.acquiring = None
+
+    def _poll_delay(self, poll_interval: float, attempt: int) -> float:
+        # A single-file lock retries on a fixed cadence. A backend that publishes several files per acquisition sets a
+        # cap, and then contending processes back off across a jittered, exponentially widening window instead of
+        # colliding on every poll; poll_interval stays the floor so a lone waiter is still responsive.
+        if not self._poll_backoff_cap:
+            return poll_interval
+        # Cap the exponent before doubling: under heavy contention attempt reaches the thousands, and 2**attempt would
+        # overflow the float multiply long before the window itself stops growing past the cap.
+        window = min(
+            self._poll_backoff_cap, poll_interval * 2 ** min(attempt, _MAX_BACKOFF_EXPONENT)
+        )  # pragma: needs hard-link
+        return max(poll_interval, secrets.randbelow(int(window * 1_000_000) + 1) / 1_000_000)  # pragma: needs hard-link
+
+    def _reconcile_failed_acquire(self, canonical: str) -> None:
+        # An acquire that raised while still holding the native lock (a hook that failed and whose rollback could not
+        # release) must keep the registry entry so a later release can retry the OS unlock; otherwise roll the counter
+        # back. is_locked was already reconciled by whichever release ran.
+        if self.is_locked:
+            self._commit_acquire(canonical)
+        else:
+            self._undo_acquire()
+
+    def _invoke_on_acquired(self) -> None:
+        # The wrapper runs in the backend executor for async locks, preserving the callback's documented thread.
+        if self._on_acquired is None or self._context.lock_counter != 1:
+            return
+        try:
+            self._on_acquired(cast("int", self._context.lock_file_fd))
+        except BaseException as callback_error:  # arbitrary caller code; roll back on any failure
+            callback_context = callback_error.__context__
+            try:
+                self._release_with_fork_tracking()
+            except BaseException as release_error:  # ruff:ignore[blind-except]  # both errors surface via the group below
+                _raise_body_and_release(callback_error, release_error)
+            callback_error.__context__ = callback_context
+            raise
+
+    def _acquire_with_fork_tracking(self) -> None:
+        with _fork_transition(self):
+            try:
+                self._acquire()
+            except BaseException as acquisition_error:
+                self._rollback_failed_acquire(acquisition_error)
+                raise
+            try:
+                self._register_context_descriptor()
+            except BaseException as registration_error:  # pragma: needs fork
+                self._rollback_failed_registration(registration_error)
+                raise
+        if self.is_locked:
+            self._invoke_on_acquired()
+
+    def _rollback_failed_acquire(self, acquisition_error: BaseException) -> None:
+        if not self.is_locked:
+            return
+        registration_error: BaseException | None = None
+        tracking_error: BaseException | None = None
+        try:
+            self._register_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # preserve registration and acquisition failures
+            registration_error = error
+            try:
+                # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+                self._register_unverified_context_descriptor()
+            except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+                tracking_error = error
+        try:
+            self._release_with_fork_tracking()
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and acquisition failures
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed",
+                acquisition_error,
+                registration_error,
+                tracking_error,
+                rollback_error,
+            )
+        if registration_error is not None:  # pragma: needs fork
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed", acquisition_error, registration_error, tracking_error
+            )
+
+    def _rollback_failed_registration(self, registration_error: BaseException) -> None:  # pragma: needs fork
+        tracking_error: BaseException | None = None
+        try:
+            # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+            self._register_unverified_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+            tracking_error = error
+        try:
+            self._release_with_fork_tracking()
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and registration failures
+            _raise_cleanup_errors(
+                "descriptor registration cleanup failed", registration_error, tracking_error, rollback_error
+            )
+        if tracking_error is not None:  # pragma: no cover - requires failed in-memory fallback
+            _raise_cleanup_errors("descriptor registration cleanup failed", registration_error, tracking_error)
+
+    def _release_with_fork_tracking(self) -> None:
+        with _fork_transition(self):
+            try:
+                self._release()
+            except BaseException as release_error:
+                # A backend unlocks first and clears the descriptor second. A signal handler that raises in between
+                # leaves a hold the OS dropped. A failed system call alone shows the lock is still held, so it keeps it.
+                if self._context.lock_file_fd is not None and not _is_system_call_failure(release_error):
+                    with contextlib.suppress(Exception):
+                        self._release()
+                raise
+            finally:
+                self._unregister_released_descriptor()
+
+    def _register_context_descriptor(self) -> None:
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:
+            self._context.lock_file_fd_token = _register_owned_descriptor(
+                self._context.lock_file_fd,
+                self._context.lock_file_fd_identity,
+            )
+
+    def _register_unverified_context_descriptor(self) -> None:
+        # The rollback only reaches here still holding a descriptor it never managed to register.
+        if self._context.lock_file_fd is not None and self._context.lock_file_fd_token is None:  # pragma: no branch
+            self._context.lock_file_fd_token = _register_unverified_owned_descriptor(self._context.lock_file_fd)
+
+    def _unregister_released_descriptor(self) -> None:
+        if self._context.lock_file_fd is None:
+            if (token := self._context.lock_file_fd_token) is not None:  # pragma: needs fork
+                _unregister_owned_descriptor(token)
+            self._context.lock_file_fd_token = None
+            self._context.lock_file_fd_identity = None
+
+    def _undo_acquire(self) -> None:
+        """Roll back the counter after a failed acquire, dropping the registry entry once nothing holds the path."""
+        self._context.lock_counter = max(0, self._context.lock_counter - 1)
+        if self._context.lock_counter == 0:
+            self._drop_registry_entry()
+            self._context.claim_root = None
+
+    def _pin_lock_path(self, canonical: str) -> None:
+        # A path without a final component names no file. Its canonical form is a directory, and pinning that would
+        # change the error the backend raises.
+        self._context.claim_root = None if canonical.endswith(os.sep) else canonical
+
+    def _commit_acquire(self, canonical: str) -> None:
+        """Record this instance as the holder once the first acquire succeeds, so peers can detect the deadlock."""
+        # Keyed on the registry rather than the counter: an on_acquired hook that acquires again bumps the counter
+        # past 1 before this first commit runs, and must not leave the hold unregistered.
+        if self._context.lock_file_registry is None:
+            key = self._registry_key(canonical)
+            # The holder scope is resolved once at commit so a later release from another flow drops the right entry.
+            self._context.lock_file_key = key
+            # A shared instance may be released from another thread, which must clear the entry in the acquirer's
+            # registry: the releaser's own thread-local registry never held it.
+            self._context.lock_file_registry = _registry.held
+            _registry.held[key] = self._holder_id
+
+    def _drop_registry_entry(self) -> None:
+        """Forget the key owned by this hold without resolving a mutable path again."""
+        # Ordered so a run an interrupt cuts short repeats safely: the entry goes only while it is still ours, and the
+        # key outlives the registry it indexes, so a later commit sees no registry and records the hold afresh.
+        key, registry = self._context.lock_file_key, self._context.lock_file_registry
+        if registry is not None and registry.get(key) == self._holder_id:
+            del registry[key]
+        self._context.lock_file_registry = None
+        self._context.lock_file_key = None
+
+    def _commit_release(self) -> None:
+        """Record the lock as fully released: reset the recursion counter and drop the deadlock-registry entry."""
+        self._context.lock_counter = 0
+        self._drop_registry_entry()
+        self._context.claim_root = None
+
+    def _try_break_expired_lock(self) -> None:
+        """Remove the lock file once it is older than :attr:`lifetime`; only an existence lock accepts one."""
+
+    def _check_give_up(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        start_time: float,
+    ) -> bool:
+        lock_id, lock_filename = id(self), self.lock_file
+        if blocking is False:
+            _LOGGER.debug("Failed to immediately acquire lock %s on %s", lock_id, lock_filename)
+            return True
+        if cancel_check is not None and cancel_check():
+            _LOGGER.debug("Cancellation requested for lock %s on %s", lock_id, lock_filename)
+            return True
+        if 0 <= timeout < time.perf_counter() - start_time:
+            _LOGGER.debug("Timeout on acquiring lock %s on %s", lock_id, lock_filename)
+            return True
+        return False
+
+    def _unprobeable_holder(self) -> str | None:  # ruff:ignore[no-self-use]  # existence locks override it
+        return None
+
+    @abstractmethod
+    def _acquire(self) -> None:
+        """If the file lock could be acquired, self._context.lock_file_fd holds the file descriptor of the lock file."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def _release(self) -> None:
+        """Releases the lock and sets self._context.lock_file_fd to None."""
+        raise NotImplementedError
+
+
+def _resolve_read_write_timeout(timeout: float, *, blocking: bool) -> float:
+    """Validate a read-write lock's acquire ``timeout``: ``-1`` or a non-negative number, ``inf`` meaning ``-1``."""
+    if (timeout := _resolve_timeout(timeout, blocking=blocking)) < 0 and timeout != -1 and blocking:
+        msg = f"timeout must be a non-negative number or -1, not {timeout!r}"
+        raise ValueError(msg)
+    return timeout
+
+
+def _acquire_thread_lock(
+    lock: Lock, *, blocking: bool, timeout: float, poll_interval: float, cancel_check: Callable[[], bool] | None
+) -> bool:
+    """Take a read-write lock's in-process lock; with *cancel_check*, ask it every *poll_interval* while waiting."""
+    if not blocking:
+        return lock.acquire(blocking=False)
+    if cancel_check is None:
+        # Lock.acquire raises OverflowError past TIMEOUT_MAX, which is 49.7 days on Windows.
+        return lock.acquire() if timeout == -1 else lock.acquire(timeout=min(timeout, TIMEOUT_MAX))
+    deadline = None if timeout == -1 else time.perf_counter() + timeout
+    while not lock.acquire(
+        timeout=poll_interval if deadline is None else min(poll_interval, max(deadline - time.perf_counter(), 0))
+    ):
+        if cancel_check() or (deadline is not None and time.perf_counter() >= deadline):
+            return False
+    return True
+
+
+def _resolve_timeout(timeout: float, *, blocking: bool) -> float:
+    """Validate an acquire ``timeout``; every negative value waits without a limit."""
+    if math.isnan(timeout := _seconds("timeout", timeout)) and blocking:
+        msg = "timeout must be a number of seconds, not nan"
+        raise ValueError(msg)
+    # The fail-fast deadlock check only sees a negative timeout as unlimited, so spell inf that way.
+    return -1 if timeout == math.inf else timeout
+
+
+@dataclass(slots=True, weakref_slot=True)
+class _FinalizerState:
+    """A finalized lock's state, held for the release that runs once the lock is unreachable."""
+
+    state: dict[str, object] | None
+
+
+#: Weak references whose callback finishes a singleton's finalizer once the cache no longer finds it.
+_UNREACHABLE_LOCKS: Final[set[ref[BaseFileLock]]] = set()
+
+
+def _finalize_unreachable(holder: ref[_FinalizerState], cls: type[BaseFileLock], reference: ref[BaseFileLock]) -> None:
+    _UNREACHABLE_LOCKS.discard(reference)
+    if (finalizer_state := holder()) is None or (state := finalizer_state.state) is None:
+        return  # pragma: no cover  # only a collector freeing a resurrected lock as part of a cycle drops the holder
+    # The lock's dictionary points back at the holder; that cycle ends here.
+    finalizer_state.state = None
+    # The release methods only read and write this state, so a fresh instance takes it over. Dropping that instance
+    # runs __del__ again, and the cache no longer finds the lock.
+    stand_in = object.__new__(cls)
+    stand_in.__dict__ = state
+    del stand_in
+
+
+def _is_system_call_failure(error: BaseException) -> bool:
+    # A failed system call sets errno. A bare TimeoutError raised by a signal handler is an OSError without one.
+    if _is_exception_group(error):
+        return all(map(_is_system_call_failure, cast("_ExceptionGroupProtocol", error).exceptions))
+    return isinstance(error, OSError) and error.errno is not None
+
+
+def _on_this_stack(frame: FrameType | None) -> bool:
+    if frame is None:
+        return False
+    caller = inspect.currentframe()
+    while caller is not None and caller is not frame:
+        caller = caller.f_back
+    return caller is not None
+
+
+# acquire() returns this wrapper instead of self so entering the with-statement does not call __enter__ a second
+# time; returning self would re-acquire the lock in BaseFileLock.__enter__ without a matching release (issue #37).
+class AcquireReturnProxy(Generic[_LockT]):
+    """A context-aware object that will release the lock file when exiting."""
+
+    def __init__(self, lock: _LockT) -> None:
+        self.lock: _LockT = lock
+
+    def __enter__(self) -> _LockT:
+        return self.lock
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        # Widen to the bound: ty narrows the else branch to the type variable minus BaseFileLock, not to the union rest.
+        lock: Final = cast("BaseFileLock | ReadWriteLock | SoftReadWriteLock", self.lock)
+        if isinstance(lock, BaseFileLock):
+            lock._release_in_context(exc_value)  # ruff:ignore[private-member-access]  # forwards __exit__ to the owned lock's context release
+        else:  # a reader/writer lock does not carry a context_error_policy
+            lock.release()
+
+
+@dataclass
+class FileLockContext:
+    """Holds the context for a ``BaseFileLock`` object."""
+
+    # A separate class so ThreadLocalFileContext can make the whole context thread-local.
+
+    lock_file: str
+    timeout: float
+    mode: int
+    blocking: bool
+    poll_interval: float
+
+    #: The lock lifetime in seconds; ``None`` means the lock never expires.
+    lifetime: float | None = None
+
+    #: File descriptor from os.open for the lock file; not None while the lock is held.
+    lock_file_fd: int | None = None
+
+    #: Registry token for the descriptor owned by this thread's context.
+    lock_file_fd_token: int | None = None
+
+    #: Identity captured by a backend that already inspected the descriptor.
+    lock_file_fd_identity: tuple[int, int] | None = None
+
+    #: Descriptor opened by a backend but not yet committed as the held lock.
+    pending_lock_file_fd: int | None = None
+
+    #: Identity captured for a descriptor whose acquisition has not committed.
+    pending_lock_file_fd_identity: tuple[int, int] | None = None
+
+    #: Depth of nested acquisitions; the lock is released only when it returns to 0.
+    lock_counter: int = 0
+
+    #: Canonical registry key captured when the first physical acquisition commits.
+    lock_file_key: Hashable | None = None
+
+    #: The acquiring thread's deadlock registry holding :attr:`lock_file_key`.
+    lock_file_registry: dict[Hashable, int] | None = None
+
+    #: Claim pathnames this owner published, removed by name on release so no holder ever unlinks a peer's claim.
+    owner_claim_paths: tuple[str, ...] = ()
+
+    #: The frame of the :meth:`BaseFileLock.release` tearing this hold down, so a re-entrant call from a signal handler
+    #: on the same thread returns instead of closing the descriptor a second time.
+    releasing: FrameType | None = None
+
+    #: The frame of an acquire still polling for this hold, so one a signal handler starts on this thread fails fast.
+    acquiring: FrameType | None = None
+
+    #: Canonical lock path, resolved when an acquisition starts and kept until its hold ends. A waiter on a relative
+    #: path stays in the directory it started in, and the release finds the file there, after a chdir in between.
+    claim_root: str | None = None
+
+    #: The lease claim of this hold, kept with it so a cross-thread release stops the right heartbeat.
+    lease_claim: _LeaseClaim | None = None
+
+
+class ThreadLocalFileContext(FileLockContext, local):
+    """
+    A thread local version of the ``FileLockContext`` class.
+
+    Each thread's state lives in an ordinary :class:`FileLockContext` at :attr:`current`, which the lock also keeps, so
+    ``release(force=True)`` and the finalizer can unlock a hold whose thread exited.
+    """
+
+    current: FileLockContext
+
+    # threading.local runs __init__ again with these arguments the first time each thread touches the context.
+    def __init__(  # ruff:ignore[too-many-arguments]  # mirrors the FileLockContext fields set at construction
+        self,
+        *,
+        lock_file: str,
+        timeout: float,
+        mode: int,
+        blocking: bool,
+        poll_interval: float,
+        lifetime: float | None = None,
+    ) -> None:
+        self.current = FileLockContext(
+            lock_file=lock_file,
+            timeout=timeout,
+            mode=mode,
+            blocking=blocking,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+        )
+
+
+def _delegate_to_current(name: str) -> property:
+    return property(
+        lambda context: getattr(context.current, name),
+        lambda context, value: setattr(context.current, name, value),
+    )
+
+
+for _field in fields(FileLockContext):
+    setattr(ThreadLocalFileContext, _field.name, _delegate_to_current(_field.name))
+
+
+@dataclass(frozen=True)
+class _OwnedDescriptor:
+    fd: int
+    creator_pid: int
+    device: int | None
+    inode: int | None
+
+
+class _ForkState:
+    def __init__(self) -> None:
+        self.gate = Condition(RLock())
+        self.registry_lock = RLock()
+        self.parameter_models_lock = RLock()
+        self.transitions: dict[int, dict[int, _ForkDescriptorOwner | None]] = {}
+        self.active_transitions = 0
+        self.admission_closed = False
+        self.fork_owner_depths: dict[int, int] = {}
+        self.pinned_objects: dict[int, list[tuple[_ForkResettable, ...]]] = {}
+        self.pinned_classes: dict[int, list[tuple[_ForkResettableClass, ...]]] = {}
+        self.provisional_descriptor_tokens: dict[int, list[tuple[int, ...]]] = {}
+        self.pid = os.getpid()
+
+    def reset_synchronization(self) -> None:  # pragma: forked child
+        self.gate = Condition(RLock())
+        self.registry_lock = RLock()
+        self.parameter_models_lock = RLock()
+        self.transitions = {}
+        self.active_transitions = 0
+        self.admission_closed = False
+        self.fork_owner_depths = {}
+        self.pinned_objects = {}
+        self.pinned_classes = {}
+        self.provisional_descriptor_tokens = {}
+
+
+_FORK_OBJECTS: Final[WeakValueDictionary[int, _ForkResettable]] = WeakValueDictionary()
+_FORK_CLASSES: Final[WeakValueDictionary[int, _ForkResettableClass]] = WeakValueDictionary()
+_OWNED_DESCRIPTORS: Final[dict[int, _OwnedDescriptor]] = {}
+_DESCRIPTOR_TOKENS: Final[count[int]] = count()
+_TRANSITION_TOKENS: Final[count[int]] = count()
+_FORK_STATE: Final = _ForkState()
+_FORK_AUDIT_EVENTS: Final[frozenset[str]] = frozenset({"os.fork", "os.forkpty"})
+# CPython before 3.12 guards sys.settrace with one process-wide flag that stays set while audit hooks run, so a thread
+# switch inside a Python hook makes a concurrent settrace raise. Coverage and debuggers call it on every thread start.
+_SETTRACE_SURVIVES_AUDIT_HOOKS: Final[bool] = sys.implementation.name != "cpython" or sys.version_info >= (3, 12)
+
+
+@cache
+def _resolve_lazy_imports_before_shutdown() -> None:
+    if hasattr(types, "LazyImportType"):  # pragma: >=3.15 cover
+        atexit.register(_resolve_lazy_imports)
+
+
+def _resolve_lazy_imports() -> None:  # pragma: >=3.15 cover
+    # Interpreter shutdown clears sys.modules and sys.meta_path before it finalizes a lock still alive at exit, so a
+    # lazy import (PEP 810) that the release path in __del__ reaches first can no longer load. Load them while it can.
+    for name, module in list(sys.modules.items()):
+        if name == "filelock" or name.startswith("filelock."):
+            for attribute, value in list(vars(module).items()):
+                if type(value) is types.LazyImportType:
+                    getattr(module, attribute)
+
+
+def _register_fork_hooks() -> None:
+    if _REGISTER_AT_FORK is None:
+        return  # pragma: lacks fork
+    if _SETTRACE_SURVIVES_AUDIT_HOOKS:  # pragma: needs fork  # pragma: needs settrace-safe-audit-hooks
+        sys.addaudithook(_audit_fork_safety)
+    _REGISTER_AT_FORK(  # pragma: needs fork
+        before=_pin_fork_objects,
+        after_in_parent=_resume_parent_after_fork,
+        after_in_child=_reset_child_after_fork,
+    )
+
+
+@contextmanager
+def _fork_transition(descriptor_owner: _ForkDescriptorOwner | None = None) -> Generator[None]:
+    # No fork follows exit, and a daemon thread stopped inside this bookkeeping holds its lock forever.
+    if not _HAS_REGISTER_AT_FORK or sys.is_finalizing():
+        yield  # pragma: lacks fork
+        return  # pragma: lacks fork
+    _ensure_current_process()  # pragma: needs fork
+    creator_pid = os.getpid()  # pragma: needs fork
+    # A generator holding this transition can be finalized on another thread, which must close the entering thread's.
+    thread_id: Final = get_ident()  # pragma: needs fork
+    token: Final = _enter_fork_transition(descriptor_owner, thread_id)  # pragma: needs fork
+    try:  # pragma: needs fork
+        yield
+    finally:
+        if os.getpid() == creator_pid:  # pragma: needs fork
+            _leave_fork_transition(token, thread_id)
+
+
+def _register_fork_object(instance: _ForkResettable) -> None:
+    if not _HAS_REGISTER_AT_FORK:
+        return  # pragma: lacks fork
+    with _fork_transition(), _FORK_STATE.registry_lock:  # pragma: needs fork
+        _FORK_OBJECTS[id(instance)] = instance
+        _refresh_owner_pins()
+
+
+def _register_fork_class(cls: _ForkResettableClass) -> None:
+    if not _HAS_REGISTER_AT_FORK:
+        return  # pragma: lacks fork
+    with _fork_transition(), _FORK_STATE.registry_lock:  # pragma: needs fork
+        _FORK_CLASSES[id(cls)] = cls
+        _refresh_owner_pins()
+
+
+def _register_owned_descriptor(fd: int, identity: tuple[int, int] | None = None) -> int | None:
+    if not _HAS_REGISTER_AT_FORK:
+        return None  # pragma: lacks fork
+    with _fork_transition():  # pragma: needs fork
+        if identity is None:
+            stat_result = os.fstat(fd)
+            identity = stat_result.st_dev, stat_result.st_ino
+        return _record_owned_descriptor(fd, identity)
+
+
+def _register_unverified_owned_descriptor(fd: int) -> int | None:
+    if not _HAS_REGISTER_AT_FORK:
+        return None  # pragma: lacks fork
+    with _fork_transition():  # pragma: needs fork
+        return _record_owned_descriptor(fd, None)
+
+
+def _record_owned_descriptor(fd: int, identity: tuple[int, int] | None) -> int:  # pragma: needs fork
+    with _FORK_STATE.registry_lock:
+        token = next(_DESCRIPTOR_TOKENS)
+        _OWNED_DESCRIPTORS[token] = _OwnedDescriptor(
+            fd=fd,
+            creator_pid=os.getpid(),
+            device=None if identity is None else identity[0],
+            inode=None if identity is None else identity[1],
+        )
+    return token
+
+
+def _unregister_owned_descriptor(token: int) -> None:  # pragma: needs fork
+    # No fork follows exit, and a daemon thread stopped inside this bookkeeping holds its lock forever.
+    if sys.is_finalizing():  # pragma: no cover  # only exit reaches it, after coverage stops measuring
+        return
+    with _fork_transition(), _FORK_STATE.registry_lock:
+        _OWNED_DESCRIPTORS.pop(token, None)
+
+
+def _pin_fork_objects() -> None:  # pragma: needs fork
+    _ensure_current_process()
+    thread_id = get_ident()
+    provisional_descriptor_tokens: list[int] = []
+    # A signal handler that raises during the wait does not stop the fork. The after hooks pop one snapshot per
+    # admission closed here, so the finally records the snapshot on failure too.
+    try:
+        with _FORK_STATE.gate:
+            _FORK_STATE.fork_owner_depths[thread_id] = _FORK_STATE.fork_owner_depths.get(thread_id, 0) + 1
+            _FORK_STATE.admission_closed = True
+            while _FORK_STATE.active_transitions > len(_FORK_STATE.transitions.get(thread_id, ())):
+                _FORK_STATE.gate.wait()
+            transition_owners = tuple(_FORK_STATE.transitions.get(thread_id, {}).values())
+        _verify_unverified_descriptors()
+        owners = {id(owner): owner for owner in transition_owners if owner is not None}
+        provisional_descriptor_tokens.extend(
+            starmap(
+                _snapshot_descriptor_for_fork,
+                (descriptor for owner in owners.values() for descriptor in owner._descriptors_for_fork()),  # ruff:ignore[private-member-access]  # snapshots each owner's own fork descriptors
+            )
+        )
+    finally:
+        with _FORK_STATE.registry_lock:
+            _FORK_STATE.provisional_descriptor_tokens.setdefault(thread_id, []).append(
+                tuple(provisional_descriptor_tokens)
+            )
+            _FORK_STATE.pinned_objects.setdefault(thread_id, []).append(tuple(_FORK_OBJECTS.values()))
+            _FORK_STATE.pinned_classes.setdefault(thread_id, []).append(tuple(_FORK_CLASSES.values()))
+
+
+def _resume_parent_after_fork() -> None:  # pragma: needs fork
+    thread_id = get_ident()
+    try:
+        with _FORK_STATE.registry_lock:
+            for token in _FORK_STATE.provisional_descriptor_tokens[thread_id].pop():
+                _OWNED_DESCRIPTORS.pop(token, None)
+            _FORK_STATE.pinned_objects[thread_id].pop()
+            _FORK_STATE.pinned_classes[thread_id].pop()
+            if not _FORK_STATE.provisional_descriptor_tokens[thread_id]:  # pragma: needs fork
+                del _FORK_STATE.provisional_descriptor_tokens[thread_id]
+                del _FORK_STATE.pinned_objects[thread_id]
+                del _FORK_STATE.pinned_classes[thread_id]
+    finally:
+        # No other code reopens admission. A failure above would leave the other threads waiting for good.
+        with _FORK_STATE.gate:
+            # A handler that raised before the depth was stored left no entry to decrement.
+            if (depth := _FORK_STATE.fork_owner_depths.get(thread_id, 1)) <= 1:
+                _FORK_STATE.fork_owner_depths.pop(thread_id, None)
+            else:  # pragma: no cover - earlier at-fork callbacks may deadlock first
+                _FORK_STATE.fork_owner_depths[thread_id] = depth - 1
+            _FORK_STATE.admission_closed = bool(_FORK_STATE.fork_owner_depths)
+            _FORK_STATE.gate.notify_all()
+
+
+def _ensure_current_process() -> None:
+    _reset_child_after_fork()
+
+
+def _reset_child_after_fork() -> None:  # pragma: forked child
+    if (pid := os.getpid()) == _FORK_STATE.pid:
+        return
+    thread_id = get_ident()
+    pinned_objects = _FORK_STATE.pinned_objects.get(thread_id, [()])[-1]
+    pinned_classes = _FORK_STATE.pinned_classes.get(thread_id, [()])[-1]
+    descriptors: list[_OwnedDescriptor] = []
+    for token, descriptor in tuple(_OWNED_DESCRIPTORS.items()):
+        if descriptor.creator_pid != pid:
+            descriptors.append(_OWNED_DESCRIPTORS.pop(token))
+    _FORK_STATE.reset_synchronization()
+    _FORK_STATE.pid = pid
+    _INIT_PARAMETER_MODELS.clear()
+    _detach_child_state(descriptors, pinned_objects, pinned_classes)
+
+
+def _enter_fork_transition(descriptor_owner: _ForkDescriptorOwner | None, thread_id: int) -> int:  # pragma: needs fork
+    with _FORK_STATE.gate:
+        while (
+            _FORK_STATE.admission_closed
+            and thread_id not in _FORK_STATE.fork_owner_depths
+            and thread_id not in _FORK_STATE.transitions
+        ):
+            _FORK_STATE.gate.wait()  # pragma: no cover - exercised in isolated interpreter
+        token = next(_TRANSITION_TOKENS)
+        _FORK_STATE.transitions.setdefault(thread_id, {})[token] = descriptor_owner
+        _FORK_STATE.active_transitions += 1
+    return token
+
+
+def _leave_fork_transition(token: int, thread_id: int) -> None:  # pragma: needs fork
+    with _FORK_STATE.gate:
+        owned: Final = _FORK_STATE.transitions[thread_id]
+        del owned[token]
+        if not owned:
+            del _FORK_STATE.transitions[thread_id]
+        _FORK_STATE.active_transitions -= 1
+        _FORK_STATE.gate.notify_all()
+
+
+def _verify_unverified_descriptors() -> None:  # pragma: needs fork
+    with _FORK_STATE.registry_lock:
+        for token, descriptor in tuple(_OWNED_DESCRIPTORS.items()):
+            if descriptor.creator_pid != os.getpid() or descriptor.device is not None:
+                continue
+            try:
+                stat_result = os.fstat(descriptor.fd)
+            except OSError:
+                continue
+            _OWNED_DESCRIPTORS[token] = _OwnedDescriptor(
+                fd=descriptor.fd,
+                creator_pid=descriptor.creator_pid,
+                device=stat_result.st_dev,
+                inode=stat_result.st_ino,
+            )
+
+
+def _snapshot_descriptor_for_fork(fd: int, identity: tuple[int, int] | None) -> int:  # pragma: needs fork
+    if identity is None:  # pragma: needs fork
+        try:
+            stat_result = os.fstat(fd)
+        except OSError:
+            pass
+        else:
+            identity = stat_result.st_dev, stat_result.st_ino
+    return _record_owned_descriptor(fd, identity)
+
+
+def _detach_child_state(  # pragma: forked child
+    descriptors: list[_OwnedDescriptor],
+    pinned_objects: tuple[_ForkResettable, ...],
+    pinned_classes: tuple[_ForkResettableClass, ...],
+) -> None:
+    for descriptor in descriptors:
+        if descriptor.device is None:
+            continue
+        try:
+            stat_result = os.fstat(descriptor.fd)
+        except OSError:
+            continue
+        if (stat_result.st_dev, stat_result.st_ino) != (descriptor.device, descriptor.inode):
+            continue
+        with contextlib.suppress(OSError):
+            os.close(descriptor.fd)
+    for instance in pinned_objects:
+        instance._reset_after_fork_in_child()  # ruff:ignore[private-member-access]  # resets each pinned instance in the fork child
+    for cls in pinned_classes:
+        cls._reset_class_after_fork()
+    _registry.held.clear()
+
+
+def _refresh_owner_pins() -> None:  # pragma: needs fork
+    with _FORK_STATE.gate:
+        fork_owner_thread_ids = tuple(_FORK_STATE.fork_owner_depths)
+    if get_ident() not in fork_owner_thread_ids:  # pragma: no cover - at-fork callbacks disable tracing
+        return
+    objects = tuple(_FORK_OBJECTS.values())
+    classes = tuple(_FORK_CLASSES.values())
+    for thread_id in fork_owner_thread_ids:
+        if object_snapshots := _FORK_STATE.pinned_objects.get(thread_id):  # pragma: needs fork
+            object_snapshots[:] = [objects] * len(object_snapshots)
+            _FORK_STATE.pinned_classes[thread_id][:] = [classes] * len(object_snapshots)
+
+
+# The defaults capture the module globals: the hook outlives them at interpreter shutdown, where CPython wipes the
+# module dict to None before the final audit events fire.
+def _audit_fork_safety(  # pragma: no cover - CPython disables tracing while Python audit hooks run
+    event: str,
+    _args: Unused,
+    *,
+    _fork_events: frozenset[str] = _FORK_AUDIT_EVENTS,
+    _state: _ForkState = _FORK_STATE,
+    _get_ident: Callable[[], int] = get_ident,
+) -> None:
+    if event in _fork_events:
+        if _get_ident() in _state.transitions or _state.fork_owner_depths:
+            msg = f"{event} is unsafe while filelock is changing descriptor ownership"
+            raise RuntimeError(msg)
+    elif event == "_posixsubprocess.fork_exec" and _get_ident() in _state.transitions:
+        msg = "fork_exec is unsafe while filelock is changing descriptor ownership"
+        raise RuntimeError(msg)
+
+
+_register_fork_hooks()
+
+
+__all__ = [
+    "_UNSET_FILE_MODE",
+    "AcquireReturnProxy",
+    "BaseFileLock",
+    "CloseErrorPolicy",
+    "ContextErrorPolicy",
+    "FileLockContext",
+    "FileLockMeta",
+    "LockOptions",
+    "ThreadLocalFileContext",
+    "_acquire_thread_lock",
+    "_append_exception_context",
+    "_canonical",
+    "_check_timeout_max",
+    "_delegate_to_current",
+    "_ensure_current_process",
+    "_fork_transition",
+    "_grouped_errors",
+    "_raise_body_and_release",
+    "_raise_chained_errors",
+    "_raise_cleanup_errors",
+    "_raise_grouped_errors",
+    "_register_fork_class",
+    "_register_fork_object",
+    "_register_owned_descriptor",
+    "_resolve_poll_interval",
+    "_resolve_read_write_timeout",
+    "_resolve_timeout",
+    "_seconds",
+    "_timeout_behavior",
+    "_unregister_owned_descriptor",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7a8fc2aacd8989132e919189d1362617de63308
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async.py
@@ -0,0 +1,507 @@
+"""Separate caller cancellation from backend task and executor-future results."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["asyncio", "collections", "concurrent.futures", "filelock._error"]
+
+import asyncio
+import contextlib
+import time
+from collections import deque
+from concurrent.futures import Future as ConcurrentFuture
+from dataclasses import dataclass
+from threading import Lock
+from typing import TYPE_CHECKING, Final, Generic, Literal, NoReturn, TypeVar, cast
+from weakref import WeakKeyDictionary
+
+from filelock._api import (
+    _append_exception_context,
+    _fork_transition,
+    _raise_chained_errors,
+    _resolve_read_write_timeout,
+)
+from filelock._error import Timeout
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Awaitable, Callable
+    from concurrent.futures import Executor
+
+    from filelock._read_write import ReadWriteLock
+    from filelock._soft_rw import SoftReadWriteLock
+
+_T = TypeVar("_T")
+
+#: The holder an async wrapper records its backend level under. No thread has this identifier, so sync code on the
+#: executor thread that took the level cannot re-enter or release it.
+_TASKS_THREAD_ID: Final[int] = 0
+
+
+class _AsyncTransitionUnavailableError(Exception):
+    pass
+
+
+@dataclass(frozen=True)
+class _BackendOutcome(Generic[_T]):
+    value: _T | None = None
+    error: BaseException | None = None
+
+
+class _AsyncTransitionGate:
+    """
+    First-in, first-out admission for the calls that transition one lock context.
+
+    Each call queues a ticket, and the head of the queue holds the gate. A call that gives up removes its own ticket,
+    so abandoned calls do not pile up behind a long holder.
+    """
+
+    def __init__(self) -> None:
+        self._queue_lock: Final[Lock] = Lock()
+        self._queue: Final[deque[ConcurrentFuture[None]]] = deque()
+
+    @contextlib.asynccontextmanager
+    async def hold(self) -> AsyncGenerator[None]:
+        ticket: ConcurrentFuture[None] = ConcurrentFuture()
+        try:
+            self._join(ticket)
+            if not ticket.done():
+                await self._wait_for_turn(ticket, blocking=True, cancel_check=None, deadline=None, poll_interval=0.05)
+            yield
+        finally:
+            self._leave(ticket)
+
+    @contextlib.asynccontextmanager
+    async def hold_for_acquire(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        deadline: float | None,
+        poll_interval: float,
+    ) -> AsyncGenerator[None]:
+        ticket: ConcurrentFuture[None] = ConcurrentFuture()
+        try:
+            self._join(ticket)
+            if not ticket.done():
+                await self._wait_for_turn(
+                    ticket,
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    deadline=deadline,
+                    poll_interval=poll_interval,
+                )
+            yield
+        finally:
+            self._leave(ticket)
+
+    async def _wait_for_turn(
+        self,
+        ticket: ConcurrentFuture[None],
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        deadline: float | None,
+        poll_interval: float,
+    ) -> None:
+        if not blocking:
+            raise _AsyncTransitionUnavailableError
+        waiter = asyncio.wrap_future(ticket)
+        while not ticket.done():
+            if cancel_check is not None and cancel_check():
+                raise _AsyncTransitionUnavailableError
+            wait_interval = poll_interval
+            if deadline is not None:
+                if (remaining := deadline - time.perf_counter()) <= 0:
+                    raise _AsyncTransitionUnavailableError
+                wait_interval = min(wait_interval, remaining)
+            await asyncio.wait((waiter,), timeout=wait_interval)
+            # A hand-off that a signal handler's exception cut short leaves the head undone, so the head settles itself.
+            self._settle_head()
+
+    def _join(self, ticket: ConcurrentFuture[None]) -> None:
+        with self._queue_lock:
+            self._queue.append(ticket)
+            if len(self._queue) == 1:
+                ticket.set_result(None)
+
+    def _leave(self, ticket: ConcurrentFuture[None]) -> None:
+        with self._queue_lock:
+            try:
+                self._queue.remove(ticket)
+            except ValueError:
+                # The join never completed, or this ticket already left.
+                return
+            self._settle_head_locked()
+
+    def _settle_head(self) -> None:
+        with self._queue_lock:
+            self._settle_head_locked()
+
+    def _settle_head_locked(self) -> None:
+        if self._queue and not (head := self._queue[0]).done():
+            head.set_result(None)
+
+
+@dataclass
+class _TaskHold:
+    """
+    One task's hold, as the nesting count per wrapper it entered through.
+
+    A task's hold ends when its last wrapper level is released or closed. Closing one wrapper ends only the levels
+    taken through it.
+    """
+
+    depths: dict[object, int]
+
+
+class _TaskOwners:
+    """
+    Per-task ownership in front of a sync reader/writer lock that tracks threads.
+
+    An async wrapper runs each call on an executor thread, and that thread does not identify the calling task. Waiting
+    writers block new readers so a stream of readers cannot starve them. A thread lock guards the table because tasks on
+    different event loops share it. The table stands for one backend level, taken once for all tasks. Sync code can
+    end that level directly, with ``close()`` or a forced release on a shared singleton. The next admission then
+    forgets the holds instead of letting more tasks join them.
+    """
+
+    def __init__(self) -> None:
+        self._lock: Final[Lock] = Lock()
+        self._mode: Literal["read", "write"] | None = None
+        self._holds: dict[asyncio.Task[object], _TaskHold] = {}
+        self._transitioning = False
+        self._waiting_writers = 0
+        #: One ticket per waiting call, settled on the next state change. A call that stops waiting takes its own out,
+        #: so one that times out or is canceled leaves nothing behind.
+        self._waiters: dict[ConcurrentFuture[None], None] = {}
+
+    async def acquire(  # ruff:ignore[too-many-arguments]  # one keyword per piece of wrapper state the table consults
+        self,
+        mode: Literal["read", "write"],
+        *,
+        timeout: float,
+        blocking: bool,
+        lock_file: str,
+        via: object,
+        enter: Callable[[float], Awaitable[None]],
+        joinable: Callable[[], bool],
+    ) -> None:
+        task = _current_task()
+        timeout = _resolve_read_write_timeout(timeout, blocking=blocking)
+        deadline = None if not blocking or timeout < 0 else time.perf_counter() + timeout
+        waiting_writer = False
+        try:
+            while isinstance(
+                admission := self._admit(
+                    task, mode, lock_file, via=via, joinable=joinable, waiting_writer=waiting_writer
+                ),
+                ConcurrentFuture,
+            ):
+                try:
+                    if not blocking or (deadline is not None and time.perf_counter() >= deadline):
+                        raise Timeout(lock_file)
+                    if mode == "write" and not waiting_writer:
+                        waiting_writer = True
+                        with self._lock:
+                            self._waiting_writers += 1
+                    wait = None if deadline is None else deadline - time.perf_counter()
+                    await asyncio.wait((asyncio.wrap_future(admission),), timeout=wait)
+                finally:
+                    self._forget(admission)
+        finally:
+            if waiting_writer:
+                with self._lock:
+                    self._waiting_writers -= 1
+                    self._notify()
+        if admission == "held":
+            return
+        try:
+            await enter(-1 if deadline is None else max(0.0, deadline - time.perf_counter()))
+        except BaseException:
+            self._finish_transition(mode=None)
+            raise
+        self._finish_transition(mode=mode, holds={task: _TaskHold(depths={via: 1})})
+
+    def _admit(  # ruff:ignore[too-many-arguments]  # the acquire's state, passed through under the table lock
+        self,
+        task: asyncio.Task[object],
+        mode: Literal["read", "write"],
+        lock_file: str,
+        *,
+        via: object,
+        joinable: Callable[[], bool],
+        waiting_writer: bool,
+    ) -> Literal["held", "enter"] | ConcurrentFuture[None]:
+        with self._lock:
+            # A "held" answer trusts the backend level. Once the backend lost it, the holds are gone and the next task
+            # has to take the lock again.
+            if self._mode is not None and not self._transitioning and not joinable():
+                self._holds.clear()
+                self._mode = None
+            if (hold := self._holds.get(task)) is not None:
+                if self._mode != mode:
+                    msg = (
+                        f"Cannot acquire {mode} lock on {lock_file}: already holding a "
+                        f"{'write' if mode == 'read' else 'read'} lock "
+                        f"({'downgrade' if mode == 'read' else 'upgrade'} not allowed)"
+                    )
+                    raise RuntimeError(msg)
+                hold.depths[via] = hold.depths.get(via, 0) + 1
+                return "held"
+            writers_ahead = self._waiting_writers - waiting_writer
+            if not self._transitioning:
+                if mode == "read" and self._mode == "read" and not writers_ahead:
+                    self._holds[task] = _TaskHold(depths={via: 1})
+                    return "held"
+                if not self._holds and (mode == "write" or not writers_ahead):
+                    self._transitioning, self._mode = True, mode
+                    return "enter"
+            return self._ticket()
+
+    async def release(
+        self,
+        *,
+        force: bool,
+        lock_file: str,
+        via: object,
+        leave: Callable[[], asyncio.Future[_BackendOutcome[None]]],
+        still_held: Callable[[], bool],
+    ) -> None:
+        task = _current_task()
+        with self._lock:
+            if (hold := self._holds.get(task)) is None or via not in hold.depths:
+                if force:
+                    return
+                msg = f"Cannot release a lock on {lock_file} that is not held by this task through this wrapper"
+                raise RuntimeError(msg)
+            if not force and hold.depths[via] > 1:
+                hold.depths[via] -= 1
+                return
+            removed = hold.depths.pop(via)
+            if hold.depths:
+                return
+            del self._holds[task]
+            if self._holds:
+                return
+            self._transitioning = True
+            mode = self._mode
+        if not still_held():
+            self._finish_transition(mode=None)
+            msg = f"Cannot release a lock on {lock_file} that is not held by this task"
+            raise RuntimeError(msg)
+        try:
+            cancellation = await _drain_cancellation(leave())
+        except BaseException:
+            hold.depths[via] = removed
+            # Keep the hold for a retried release only while the sync lock still has the level. Restored after the sync
+            # lock let go, it would stand for a lock nobody holds.
+            self._finish_transition(mode=mode if still_held() else None, holds={task: hold})
+            raise
+        self._finish_transition(mode=None)
+        if cancellation is not None:
+            # The release succeeded, so a restored hold would be a phantom no backend call can clear.
+            raise cancellation
+
+    async def retire(
+        self,
+        via: object | None,
+        *,
+        leave: Callable[[], asyncio.Future[_BackendOutcome[None]]],
+        still_held: Callable[[], bool],
+    ) -> None:
+        """
+        End the holds taken through *via*, or every hold when it is ``None``, as one transition.
+
+        Leaves the backend through *leave* when that ends the last hold, and always when *via* is ``None``. Arrivals
+        wait while it runs, so none joins a hold the backend is letting go of. A transition already under way is waited
+        out first: a task entering through *via* must not get a hold after the wrapper is gone. A cancellation is raised
+        once the holds are settled.
+        """
+        cancellation: asyncio.CancelledError | None = None
+        while isinstance(settled := self._drop_holds_via(via), ConcurrentFuture):
+            try:
+                await _wait_until_done(asyncio.wrap_future(settled))
+            except asyncio.CancelledError as error:
+                cancellation = error
+            finally:
+                self._forget(settled)
+        mode, dropped = settled
+        if via is None or (mode is not None and still_held()):
+            try:
+                cancellation = await _drain_cancellation(leave()) or cancellation
+            except BaseException:
+                # A close that failed with the backend still holding stays retryable, as a failed release does.
+                self._finish_transition(mode=mode if still_held() else None, holds=dropped)
+                raise
+            self._finish_transition(mode=None)
+        elif mode is not None:
+            # Sync code already ended the level taken for tasks, so there is nothing to give back.
+            self._finish_transition(mode=None)
+        if cancellation is not None:
+            raise cancellation
+
+    def _drop_holds_via(
+        self, via: object | None
+    ) -> tuple[Literal["read", "write"] | None, dict[asyncio.Task[object], _TaskHold]] | ConcurrentFuture[None]:
+        # Returns the future a running transition settles, or else the mode to leave (None when other holds keep the
+        # backend level) and the dropped holds. The table stays transitioning while that mode is left.
+        with self._lock:
+            if self._transitioning:
+                return self._ticket()
+            if via is None:
+                dropped = dict(self._holds)
+                self._holds.clear()
+            else:
+                dropped = {}
+                for task, hold in list(self._holds.items()):
+                    if (count := hold.depths.pop(via, None)) is not None:
+                        dropped[task] = _TaskHold(depths={via: count})
+                        if not hold.depths:
+                            del self._holds[task]
+            if self._holds and via is not None:
+                return None, dropped
+            mode = self._mode
+            self._transitioning = mode is not None or via is None
+            return mode, dropped
+
+    def _finish_transition(
+        self, *, mode: Literal["read", "write"] | None, holds: dict[asyncio.Task[object], _TaskHold] | None = None
+    ) -> None:
+        with self._lock:
+            self._transitioning, self._mode = False, mode
+            if mode is not None and holds:
+                for task, hold in holds.items():
+                    self._holds.setdefault(task, _TaskHold(depths={})).depths.update(hold.depths)
+            self._notify()
+
+    def _ticket(self) -> ConcurrentFuture[None]:
+        # Called under the table lock, in the section that decided to wait, so no state change slips in between.
+        ticket: ConcurrentFuture[None] = ConcurrentFuture()
+        self._waiters[ticket] = None
+        return ticket
+
+    def _forget(self, ticket: ConcurrentFuture[None]) -> None:
+        with self._lock:
+            self._waiters.pop(ticket, None)
+
+    def _notify(self) -> None:
+        waiters, self._waiters = self._waiters, {}
+        for ticket in waiters:
+            ticket.set_result(None)
+
+
+_TASK_OWNERS: Final[WeakKeyDictionary[ReadWriteLock | SoftReadWriteLock, _TaskOwners]] = WeakKeyDictionary()
+_TASK_OWNERS_LOCK: Final[Lock] = Lock()
+
+
+def _task_owners_for(sync_lock: ReadWriteLock | SoftReadWriteLock) -> _TaskOwners:
+    """Singleton wrappers share one sync lock, so they must share its task holds too."""
+    with _fork_transition(), _TASK_OWNERS_LOCK:
+        if (owners := _TASK_OWNERS.get(sync_lock)) is None:
+            owners = _TASK_OWNERS[sync_lock] = _TaskOwners()
+        return owners
+
+
+def _current_task() -> asyncio.Task[object]:
+    if (task := asyncio.current_task()) is None:
+        msg = "an async reader/writer lock must be used from inside an asyncio task"
+        raise RuntimeError(msg)
+    return task
+
+
+async def _drain_cancellation(future: asyncio.Future[_BackendOutcome[None]]) -> asyncio.CancelledError | None:
+    # Returned, not raised, so the caller can tell a call that completed under cancellation from one that failed.
+    try:
+        await _wait_until_done(future)
+    except asyncio.CancelledError as cancellation:
+        try:
+            await _drain_future(future)
+        except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+            _raise_cancelled_error(cancellation, error)
+        return cancellation
+    _future_result(future)
+    return None
+
+
+async def _drain_future(future: asyncio.Future[_BackendOutcome[_T]]) -> _T:
+    while not future.done():
+        with contextlib.suppress(asyncio.CancelledError):
+            await _wait_until_done(future)
+    return _future_result(future)
+
+
+async def _wait_until_done(future: asyncio.Future[_T]) -> None:
+    if not future.done():
+        await asyncio.wait((future,))
+
+
+def _future_result(future: asyncio.Future[_BackendOutcome[_T]]) -> _T:
+    outcome = future.result()
+    if (error := outcome.error) is None:
+        return cast("_T", outcome.value)
+    context = error.__context__
+    try:
+        raise error  # ruff:ignore[raise-within-try]  # the handler restores context changed across the async boundary
+    except BaseException:
+        error.__context__ = context
+        raise
+
+
+def _run_in_executor(
+    loop: asyncio.AbstractEventLoop, executor: Executor | None, func: Callable[[], _T]
+) -> asyncio.Future[_BackendOutcome[_T]]:
+    outcome: asyncio.Future[_BackendOutcome[_T]] = loop.create_future()
+
+    def settle(call: asyncio.Future[_BackendOutcome[_T]]) -> None:
+        try:
+            result = call.result()
+        except asyncio.CancelledError:
+            # shutdown(cancel_futures=True) dropped the call unrun: a CancelledError would cancel a task nobody canceled
+            # and hide that the lock state never changed.
+            msg = "the executor shut down before running the lock backend call"
+            result = _BackendOutcome(error=RuntimeError(msg))
+        outcome.set_result(result)
+
+    loop.run_in_executor(executor, _capture_call, func).add_done_callback(settle)
+    return outcome
+
+
+def _capture_call(func: Callable[[], _T]) -> _BackendOutcome[_T]:
+    try:
+        return _BackendOutcome(value=func())
+    except BaseException as error:  # ruff:ignore[blind-except]  # backend control-flow exceptions are operation results
+        return _BackendOutcome(error=error)
+
+
+def _raise_cancelled_error(cancellation: asyncio.CancelledError, error: BaseException) -> NoReturn:
+    # A reconciliation step failed while unwinding a cancellation, so keep both exception chains. Splice the error's
+    # existing context onto the cancellation, then make the cancellation the error's context, so both the failure and
+    # the cancellation that triggered it survive. Shared by the async wrappers so cancellations report the same way.
+    if (context := error.__context__) is not None and context is not cancellation:
+        if (cancellation_context := cancellation.__context__) is not None:
+            _append_exception_context(context, cancellation_context)
+        cancellation.__context__ = context
+    error.__context__ = cancellation
+    _raise_chained_errors(error)
+
+
+async def _capture_awaitable(awaitable: Awaitable[_T]) -> _BackendOutcome[_T]:
+    try:
+        return _BackendOutcome(value=await awaitable)
+    except BaseException as error:  # ruff:ignore[blind-except]  # backend cancellation must remain distinct from caller cancellation
+        return _BackendOutcome(error=error)
+
+
+__all__ = [
+    "_TASKS_THREAD_ID",
+    "_AsyncTransitionGate",
+    "_AsyncTransitionUnavailableError",
+    "_BackendOutcome",
+    "_capture_awaitable",
+    "_capture_call",
+    "_drain_future",
+    "_future_result",
+    "_raise_cancelled_error",
+    "_run_in_executor",
+    "_task_owners_for",
+    "_wait_until_done",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async_read_write.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async_read_write.py
new file mode 100644
index 0000000000000000000000000000000000000000..5920457397ac02dabb9a5a184c55cbd3a1f31488
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_async_read_write.py
@@ -0,0 +1,413 @@
+"""Async wrapper around :class:`ReadWriteLock` for use with ``asyncio``."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["asyncio", "concurrent.futures", "filelock._async", "filelock._error", "functools", "threading"]
+
+import asyncio
+import functools
+import os
+import sqlite3
+import threading
+from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import thread as executor_threads
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Final, Literal, ParamSpec, TypeVar, cast
+
+from filelock._api import (
+    _append_exception_context,
+    _ensure_current_process,
+    _fork_transition,
+    _register_fork_object,
+)
+from filelock._async import (
+    _TASKS_THREAD_ID,
+    _BackendOutcome,
+    _capture_call,
+    _drain_future,
+    _future_result,
+    _raise_cancelled_error,
+    _task_owners_for,
+    _wait_until_done,
+)
+from filelock._error import Timeout
+from filelock._read_write import ReadWriteLock
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Callable, MutableMapping
+    from concurrent import futures
+    from types import TracebackType
+
+    from filelock._api import AcquireReturnProxy
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+class AsyncReadWriteLock:
+    """
+    Async wrapper around :class:`ReadWriteLock` for use in ``asyncio`` applications.
+
+    This wrapper dispatches every blocking SQLite operation to a thread pool via ``loop.run_in_executor()`` because
+    Python's :mod:`sqlite3` module has no async API. Each ``asyncio`` task owns its own hold. Tasks share a read lock,
+    and a task asking for the write lock waits until the other holders release, with waiting writers ahead of new
+    readers. As with :class:`ReadWriteLock`, upgrading or downgrading a held lock raises :class:`RuntimeError`.
+    Singleton wrappers over one path share their task holds, and closing one ends only the holds taken through it.
+
+    :param lock_file: path to the SQLite database file used as the lock
+    :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+    :param is_singleton: if ``True``, reuse existing :class:`ReadWriteLock` instances for the same resolved path
+    :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop
+    :param executor: executor for ``run_in_executor``. When ``None`` this lock creates and owns a dedicated
+        single-thread executor so every operation runs on the same thread (SQLite affinity requires this) and shuts it
+        down in :meth:`close`. This lock uses a caller-supplied executor as-is and never shuts it down, so after passing
+        no executor call :meth:`close` to release the owned one.
+
+    .. versionadded:: 3.21.0
+
+    """
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+        loop: asyncio.AbstractEventLoop | None = None,
+        executor: futures.Executor | None = None,
+    ) -> None:
+        creator_pid = os.getpid()
+        self._creator_pid = creator_pid
+        self._fork_invalidated = False
+        self._closed = False
+        self._owns_backend = not is_singleton
+        #: Marks the task holds taken through this wrapper, which its close() ends.
+        self._via: Final = object()
+        _register_fork_object(self)
+        with _fork_transition():
+            self._lock = ReadWriteLock(lock_file, timeout, blocking=blocking, is_singleton=is_singleton)
+            self._owners = _task_owners_for(self._lock)
+            self._loop = loop
+            self._owns_executor = executor is None
+            self._executor = executor or ThreadPoolExecutor(max_workers=1)
+            if os.getpid() != creator_pid:  # pragma: forked child
+                msg = "AsyncReadWriteLock construction cannot continue after fork"
+                raise RuntimeError(msg)
+
+    @property
+    def lock_file(self) -> str:
+        """The path to the lock file."""
+        return self._lock.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """The default timeout."""
+        return self._lock.timeout
+
+    @property
+    def blocking(self) -> bool:
+        """Whether blocking is enabled by default."""
+        return self._lock.blocking
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop | None:
+        """The event loop (or ``None`` for the running loop)."""
+        return self._loop
+
+    @property
+    def executor(self) -> futures.Executor:
+        """The executor used for ``run_in_executor`` (a dedicated single-thread one if none was supplied)."""
+        return self._executor
+
+    @asynccontextmanager
+    async def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases a shared read lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        await self.acquire_read(timeout, blocking=blocking)
+        body_error: BaseException | None = None
+        try:
+            yield
+        except BaseException as error:
+            body_error = error
+            raise
+        finally:
+            await self._release_in_context(body_error)
+
+    @asynccontextmanager
+    async def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases an exclusive write lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        await self.acquire_write(timeout, blocking=blocking)
+        body_error: BaseException | None = None
+        try:
+            yield
+        except BaseException as error:
+            body_error = error
+            raise
+        finally:
+            await self._release_in_context(body_error)
+
+    async def _release_in_context(self, body_error: BaseException | None) -> None:
+        try:
+            await self.release()
+        except BaseException as release_error:
+            if body_error is not None:
+                _append_exception_context(release_error, body_error)
+            raise
+
+    async def acquire_read(
+        self, timeout: float | None = None, *, blocking: bool | None = None
+    ) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        See :meth:`ReadWriteLock.acquire_read` for full semantics.
+
+        :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
+            busy-timeout cap of about 23 days
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
+            ``None`` uses the instance setting
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if the calling task already holds the write lock
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self._raise_if_unusable()
+        await self._acquire("read", timeout, blocking=blocking)
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def acquire_write(
+        self, timeout: float | None = None, *, blocking: bool | None = None
+    ) -> AsyncAcquireReadWriteReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        See :meth:`ReadWriteLock.acquire_write` for full semantics.
+
+        :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
+            busy-timeout cap of about 23 days
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
+            ``None`` uses the instance setting
+
+        :returns: a proxy that can be used as an async context manager to release the lock
+
+        :raises RuntimeError: if the calling task already holds the read lock
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self._raise_if_unusable()
+        await self._acquire("write", timeout, blocking=blocking)
+        return AsyncAcquireReadWriteReturnProxy(lock=self)
+
+    async def _acquire(self, mode: Literal["read", "write"], timeout: float | None, *, blocking: bool | None) -> None:
+        timeout = self.timeout if timeout is None else timeout
+        blocking = self.blocking if blocking is None else blocking
+
+        async def enter(remaining: float) -> None:
+            # A close() may have landed while this task waited for the table.
+            self._raise_if_unusable()
+            await self._run_acquire(
+                functools.partial(
+                    self._lock._acquire_level_of,  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+                    _TASKS_THREAD_ID,
+                    mode,
+                    remaining,
+                    blocking=blocking,
+                )
+            )
+
+        def joinable() -> bool:
+            self._raise_if_unusable()
+            return self._backend_holds()
+
+        await self._owners.acquire(
+            mode,
+            timeout=timeout,
+            blocking=blocking,
+            lock_file=self.lock_file,
+            via=self._via,
+            enter=enter,
+            joinable=joinable,
+        )
+
+    async def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the calling task's hold.
+
+        The wrapper releases the database lock once no task holds it.
+
+        :param force: if ``True``, end every level the calling task took through this wrapper. Levels taken through
+            other wrappers on the same path stay. A wrapper that holds no level for the task releases nothing.
+
+        :raises RuntimeError: if the calling task holds no level through this wrapper and *force* is ``False``
+
+        """
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            return
+        await self._owners.release(
+            force=force,
+            lock_file=self.lock_file,
+            via=self._via,
+            leave=functools.partial(self._submit, self._leave_backend),
+            still_held=self._backend_holds,
+        )
+
+    async def close(self) -> None:
+        """
+        End the holds of the tasks that acquired through this instance and release the lock once no task holds it.
+
+        After calling this method, the lock instance is no longer usable. With ``is_singleton=False`` it also closes the
+        underlying SQLite connection. A singleton wrapper leaves the shared :class:`ReadWriteLock` open, so tasks that
+        acquired through another wrapper and synchronous users of the same path keep their holds. The next acquire
+        notices a synchronous ``close()`` or forced release of that shared lock. One that lands in the few bytecodes
+        between that check and the admission still admits the task into the ended hold.
+
+        """
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            return
+        if self._closed:
+            return
+        # Refuse acquires from here on, so none is admitted into a hold the backend is letting go of.
+        self._closed = True
+        try:
+            await self._owners.retire(
+                None if self._owns_backend else self._via,
+                leave=functools.partial(self._submit, self._lock.close if self._owns_backend else self._leave_backend),
+                still_held=self._backend_holds,
+            )
+        except BaseException as error:
+            # Only a failed backend call can leave the level held, and then a retried close() has to find it.
+            if not isinstance(error, asyncio.CancelledError) and self._backend_holds():
+                self._closed = False
+            else:
+                self._shutdown_owned_executor()
+            raise
+        # Wait for the worker to exit rather than letting it drain in the background: a caller that forks right
+        # after closing deserves a single-threaded process, and os.fork warns about any surviving thread.
+        if self._owns_executor:
+            await asyncio.to_thread(functools.partial(self._executor.shutdown, wait=True))
+
+    async def _run_acquire(self, acquire: Callable[..., AcquireReturnProxy]) -> None:
+        abandoned = threading.Event()
+        acquire_future = self._submit(acquire, cancel_check=abandoned.is_set)
+        try:
+            await _wait_until_done(acquire_future)
+        except asyncio.CancelledError as cancellation:
+            # Stops a backend wait on another process's hold, which would otherwise outlast the caller by as long.
+            abandoned.set()
+            try:
+                await _drain_future(acquire_future)
+            except Timeout:
+                # Nothing was taken, so the caller's cancellation is the whole outcome.
+                raise cancellation from None
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            try:
+                await _drain_future(self._submit(self._leave_backend))
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            raise
+        _future_result(acquire_future)
+
+    def _backend_holds(self) -> bool:
+        # A sync close() or forced release on a shared singleton ends the tasks' level without the table taking part.
+        return self._lock._holds_level_of(_TASKS_THREAD_ID)  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+
+    def _leave_backend(self) -> None:
+        # Only the tasks' level: a sync user of the same singleton keeps its own.
+        self._lock._release_level_of(_TASKS_THREAD_ID)  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+
+    def _submit(
+        self, func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs
+    ) -> asyncio.Future[_BackendOutcome[_R]]:
+        return (self._loop or asyncio.get_running_loop()).run_in_executor(
+            self._executor,
+            _capture_call,
+            functools.partial(func, *args, **kwargs),
+        )
+
+    def _shutdown_owned_executor(self) -> None:
+        if self._owns_executor:
+            self._executor.shutdown(wait=False)
+
+    @property
+    def _inherited(self) -> bool:
+        return self._fork_invalidated or os.getpid() != self._creator_pid
+
+    def _raise_if_unusable(self) -> None:
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            msg = f"AsyncReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance"
+            raise RuntimeError(msg)
+        if self._closed:
+            msg = "Cannot operate on a closed database."
+            raise sqlite3.ProgrammingError(msg)
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        self._fork_invalidated = True
+        if self._owns_executor:
+            # The worker did not survive the fork, yet before 3.12 the child's exit still wakes it through its queue. On
+            # PyPy that queue is pure Python, and its lock may have been held by the worker at fork time, so exit hangs.
+            # CPython 3.12+ forgets every inherited worker in the child; do the same for the one this lock owns.
+            # typeshed declares the registry read-only; it is a WeakKeyDictionary the exit hook iterates.
+            registry = cast(
+                "MutableMapping[threading.Thread, object]",
+                executor_threads._threads_queues,  # ruff:ignore[private-member-access]  # the exit hook's registry
+            )
+            for worker in cast("ThreadPoolExecutor", self._executor)._threads:  # ruff:ignore[private-member-access]  # only the executor lists its workers
+                registry.pop(worker, None)
+
+    def __del__(self) -> None:
+        # Safety net when close() was never called: shut down the executor we own so its worker thread does not
+        # outlive the lock. shutdown(wait=False) never blocks.
+        if os.getpid() == getattr(self, "_creator_pid", None) and getattr(self, "_owns_executor", False):
+            self._executor.shutdown(wait=False)
+
+
+class AsyncAcquireReadWriteReturnProxy:
+    """Context-aware object that releases the async read/write lock on exit."""
+
+    def __init__(self, lock: AsyncReadWriteLock) -> None:
+        self.lock = lock
+
+    async def __aenter__(self) -> AsyncReadWriteLock:
+        return self.lock
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.lock.release()
+
+
+__all__ = [
+    "AsyncAcquireReadWriteReturnProxy",
+    "AsyncReadWriteLock",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_descriptor.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_descriptor.py
new file mode 100644
index 0000000000000000000000000000000000000000..61450ff9fae19481ddd7213ce8e5bf5f2d3c32f2
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_descriptor.py
@@ -0,0 +1,76 @@
+"""A minimal native lock over a caller-owned file descriptor, contending with :class:`FileLock` on the same file."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["filelock._unix", "threading", "typing"]
+
+import sys
+import time
+from threading import TIMEOUT_MAX
+from typing import Final
+
+from filelock._api import _seconds
+
+if sys.platform == "win32":  # pragma: win32 cover
+    from filelock._windows import _lock_fd_nonblocking, _unlock_fd
+else:  # pragma: win32 no cover
+    from filelock._unix import _lock_fd_nonblocking, _unlock_fd
+
+
+def lock_descriptor(fd: int, *, blocking: bool = True, poll_interval: float = 0.05) -> bool:
+    """
+    Take the native OS lock on *fd*, a file descriptor the caller opened and owns.
+
+    This is the same one-byte exclusive lock :class:`FileLock` uses, so a descriptor lock and a path lock on the same
+    file contend with each other. Unlike :class:`FileLock` it adds no path handling: it never opens, truncates, closes,
+    unlinks, chmods, canonicalizes, or falls back. The caller owns *fd* before, during, and after the call, and must
+    close it. On Windows *fd* must be a synchronous descriptor (its handle not opened with ``FILE_FLAG_OVERLAPPED``).
+
+    For timeout, reentrancy, singleton, lifetime, or stale-break behavior, use :class:`FileLock`. There is no async
+    wrapper. Run this in an executor, or drive ``blocking=False`` from your own polling loop.
+
+    :param fd: an open file descriptor the caller owns.
+    :param blocking: when ``True`` (default), retry the nonblocking attempt every *poll_interval* seconds until it
+        succeeds; when ``False``, make one attempt.
+    :param poll_interval: positive seconds between attempts while blocking, at most :data:`threading.TIMEOUT_MAX`;
+        ignored when *blocking* is ``False``.
+
+    :returns: ``True`` once the lock is held, or ``False`` on contention when ``blocking`` is ``False``.
+
+    :raises OSError: for a permanent native failure, such as an invalid descriptor, or with ``errno.ENOSYS`` when the
+        Python build lacks the native locking primitive. The descriptor is left open.
+    :raises ValueError: if a blocking call receives a *poll_interval* outside that range, including ``nan``.
+
+    .. versionadded:: 3.30.0
+
+    """
+    if not blocking:
+        return _lock_fd_nonblocking(fd)
+    # time.sleep raises OverflowError past TIMEOUT_MAX; nan fails both comparisons.
+    if not 0 < (poll_interval := _seconds("poll_interval", poll_interval)) <= TIMEOUT_MAX:
+        msg: Final[str] = f"poll_interval must be greater than 0 and at most {TIMEOUT_MAX}, got {poll_interval}"
+        raise ValueError(msg)
+    while not _lock_fd_nonblocking(fd):
+        time.sleep(poll_interval)
+    return True
+
+
+def unlock_descriptor(fd: int) -> None:
+    """
+    Release the native OS lock on *fd* without touching the descriptor.
+
+    :param fd: the descriptor a prior :func:`lock_descriptor` locked; the caller still owns and must close it.
+
+    :raises OSError: if the native unlock fails, including ``errno.ENOSYS`` when the Python build lacks the native
+        locking primitive; the caller may retry on the same descriptor.
+
+    .. versionadded:: 3.30.0
+
+    """
+    _unlock_fd(fd)
+
+
+__all__ = [
+    "lock_descriptor",
+    "unlock_descriptor",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_error.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_error.py
new file mode 100644
index 0000000000000000000000000000000000000000..fb5831306a90d2e1369c6242c7a16f52fa26fddc
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_error.py
@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["typing"]
+
+from typing import Final
+
+
+class Timeout(TimeoutError):  # ruff:ignore[error-suffix-on-exception-name]  # public exception name; renaming breaks the API
+    """Raised when the lock could not be acquired in *timeout* seconds."""
+
+    def __init__(self, lock_file: str, holder: str | None = None) -> None:
+        super().__init__()
+        self._lock_file = lock_file
+        self._holder = holder
+
+    def __reduce__(self) -> tuple[type[Timeout], tuple[str], dict[str, object]]:
+        # holder rides in the state so a subclass taking only lock_file, and a 4.0.12 reader, can still unpickle it.
+        return self.__class__, (self._lock_file,), self.__dict__
+
+    def __str__(self) -> str:  # pragma: needs hard-link
+        message: Final = f"The file lock '{self._lock_file}' could not be acquired."
+        if self._holder is None:
+            return message
+        return f"{message} It is held by {self._holder}, which this host cannot probe."
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.lock_file!r})"
+
+    @property
+    def lock_file(self) -> str:
+        """The path of the file lock."""
+        return self._lock_file
+
+
+class SoftFileLockLifetimeWarning(FutureWarning):
+    """
+    The configured soft-lock lifetime permits overlapping live holders after expiry.
+
+    A :class:`FutureWarning` shows by default wherever the lock is configured; a :class:`DeprecationWarning` shows only
+    in ``__main__``.
+
+    """
+
+
+class LeaseSettingsMismatch(ValueError):  # ruff:ignore[error-suffix-on-exception-name]  # public exception name; renaming breaks the API
+    """A lease contender disagrees with the published claim about how long the lease lasts."""
+
+
+class SoftFileLockProtocolError(OSError):
+    """Raised when strict soft-lock state cannot be interpreted without risking overlap."""
+
+    def __init__(self, lock_file: str, claim_name: str | None, reason: str) -> None:
+        self._lock_file = lock_file
+        self._claim_name = claim_name
+        self._reason = reason
+        super().__init__(self.__str__())
+
+    def __reduce__(
+        self,
+    ) -> tuple[
+        type[SoftFileLockProtocolError], tuple[str, str | None, str], dict[str, object]
+    ]:  # pragma: needs hard-link
+        return self.__class__, (self._lock_file, self._claim_name, self._reason), self.__dict__
+
+    def __str__(self) -> str:
+        location = self._lock_file if self._claim_name is None else f"{self._lock_file}: claim {self._claim_name!r}"
+        return f"Invalid strict soft-lock state at {location}: {self._reason}"
+
+    @property
+    def lock_file(self) -> str:  # pragma: needs hard-link
+        """The requested lock path."""
+        return self._lock_file
+
+    @property
+    def claim_name(self) -> str | None:  # pragma: needs hard-link
+        """The claim that caused the error, if scanning identified one."""
+        return self._claim_name
+
+    @property
+    def reason(self) -> str:  # pragma: needs hard-link
+        """The protocol validation failure."""
+        return self._reason
+
+
+__all__ = [
+    "LeaseSettingsMismatch",
+    "SoftFileLockLifetimeWarning",
+    "SoftFileLockProtocolError",
+    "Timeout",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_identity.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_identity.py
new file mode 100644
index 0000000000000000000000000000000000000000..4abc60d0406be2be484b5f2a918952c6d3cd14e7
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_identity.py
@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["hashlib", "pathlib", "socket", "typing"]
+
+import hashlib
+import os
+import socket
+import sys
+from errno import EPERM, ESRCH
+from pathlib import Path
+from typing import Final
+
+#: Every marker format in this package caps the hostname at the RFC 1123 limit and reads a longer one as malformed.
+_HOST_NAME_LIMIT: Final[int] = 253
+#: The bytes those formats carry verbatim: printable non-space ASCII, less the ``?`` reserved for the escape.
+_HOST_NAME_VERBATIM: Final[frozenset[int]] = frozenset(range(0x21, 0x7F)) - {ord("?")}
+#: The characters at the end of an over-long name that carry a digest of the part cut off.
+_HOST_NAME_DIGEST_LEN: Final[int] = 8
+#: The kernel ABI fixes the initial PID namespace's inode (``PID_NS_INIT_INO`` in ``linux/nsfs.h``); every namespace
+#: created later draws one from ``0xF0000000`` up, so this value names the host's own namespace.
+_INITIAL_PID_NAMESPACE: Final[int] = 0xEFFFFFFC
+_NAMESPACE_MARK: Final[str] = "?pidns-"
+
+
+def host_name() -> str:
+    """
+    The hostname recorded alongside an owner, so a marker written on another machine is never probed here.
+
+    Marker formats here hold the field to printable non-space ASCII, while ``socket.gethostname()`` reports whatever
+    the kernel stores: a space, a newline that forges an extra marker line, or a byte no codec encodes, which Python
+    hands back as a surrogate. A holder that publishes one raw writes a marker it cannot read back, and loses the lock
+    to the first peer that ages it out as malformed. ``?`` is illegal in a hostname, so escaping it along with every
+    out-of-grammar byte as ``?<hex>`` leaves a real name untouched and still keeps two hosts apart, which
+    :func:`owner_is_stale` relies on to refuse to probe a foreign PID.
+
+    Linux appends the PID namespace, as Mercurial's lock prefix does. Two containers in one pod share the hostname and
+    the boot id but not the PID namespace, so a PID recorded in one names another process, or none, in the other. The
+    suffix starts with a ``?`` no escape can produce, so ``a`` in a namespace never reads as a host literally named
+    ``a?pidns-...``. The initial namespace adds nothing, which keeps a host's name what older releases recorded.
+
+    An over-long name ends in a digest of the part cut to fit the limit. A bare cut gives every name that shares the
+    kept prefix one identity, and :func:`owner_is_stale` would then probe a local PID for another host's holder.
+    """
+    name = (
+        "".join(
+            chr(byte) if byte in _HOST_NAME_VERBATIM else f"?{byte:02x}"
+            for byte in socket.gethostname().encode("utf-8", "surrogateescape")
+        )
+        + _pid_namespace_suffix()
+    )
+    if len(name) > _HOST_NAME_LIMIT:
+        keep = _HOST_NAME_LIMIT - _HOST_NAME_DIGEST_LEN - 1
+        name = f"{name[:keep]}-{hashlib.sha256(name[keep:].encode()).hexdigest()[:_HOST_NAME_DIGEST_LEN]}"
+    # An escape is three characters and a kept byte is never '?', so a bare '?' can only mean an empty hostname.
+    return name or "?"
+
+
+def _pid_namespace_suffix() -> str:
+    try:
+        namespace: Final = Path("/proc/self/ns/pid").stat().st_ino
+    except OSError:  # only Linux 3.8+ has the file, and a sandbox may hide it; nothing else tells namespaces apart
+        return ""
+    return "" if namespace == _INITIAL_PID_NAMESPACE else f"{_NAMESPACE_MARK}{namespace:x}"
+
+
+def owner_is_stale(pid: int, hostname: str, start_token: int | None) -> bool:
+    """
+    Whether the recorded owner is provably gone, so reclaiming its marker cannot detach a live holder.
+
+    Fail closed: return ``True`` only when this process can prove the exact recorded owner is dead. A marker from
+    another host cannot be probed; a live PID whose start token still matches, or whose token cannot be read, is the
+    holder or is indistinguishable from it; a live PID whose start token differs is a recycled PID, so the process that
+    wrote the marker is gone. PostgreSQL, Qt ``QLockFile`` and Mercurial all break a stale lock only on proof of death
+    and treat an unreadable or foreign owner as still holding.
+    """
+    if hostname != host_name():
+        return False
+    if process_alive(pid) and (
+        start_token is None or (current := process_start_token(pid)) is None or _same_start(current, start_token)
+    ):
+        return False
+    # Only a bare hostname can be an older release's, written from a container that shares this host's name.
+    return _NAMESPACE_MARK in hostname or not _owner_runs_elsewhere(pid, start_token)
+
+
+def owner_is_current_process(pid: int, hostname: str, start_token: int | None) -> bool:
+    """
+    Whether the recorded owner is this process, so a marker a recycled PID left behind never reads as ours.
+
+    Fail closed: a recorded start token must match this process's. One that differs was written by an earlier process
+    that reused this PID, and when this process cannot read its own token nothing proves the marker is ours. A marker
+    without a token falls back to the PID and hostname.
+    """
+    if pid != os.getpid() or hostname != host_name():
+        return False
+    return start_token is None or start_token == process_start_token(pid)
+
+
+def _same_start(current: int, recorded: int) -> bool:
+    # A Linux token carries the boot id in its high 64 bits, or 0 there when the process could not read the boot id.
+    # systemd's ProcSubset=pid hides /proc/sys from one unit, so one process may lack the boot id while its peer has
+    # it. A missing boot id then proves nothing, and only starttime is compared. Other platforms' tokens fit in the
+    # low bits.
+    return current == recorded or (0 in {current >> 64, recorded >> 64} and current % 2**64 == recorded % 2**64)
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    import ctypes
+    from ctypes import wintypes
+
+    _KERNEL32: Final[ctypes.WinDLL] = ctypes.WinDLL("kernel32", use_last_error=True)
+    _KERNEL32.CloseHandle.argtypes = [wintypes.HANDLE]
+    _KERNEL32.CloseHandle.restype = wintypes.BOOL
+    _KERNEL32.OpenProcess.argtypes = [wintypes.DWORD, wintypes.BOOL, wintypes.DWORD]
+    _KERNEL32.OpenProcess.restype = wintypes.HANDLE
+    _KERNEL32.GetProcessTimes.argtypes = [
+        wintypes.HANDLE,
+        ctypes.POINTER(wintypes.FILETIME),
+        ctypes.POINTER(wintypes.FILETIME),
+        ctypes.POINTER(wintypes.FILETIME),
+        ctypes.POINTER(wintypes.FILETIME),
+    ]
+    _KERNEL32.GetProcessTimes.restype = wintypes.BOOL
+
+    _WIN_SYNCHRONIZE: Final[int] = 0x100000
+    _WIN_PROCESS_QUERY_LIMITED_INFORMATION: Final[int] = 0x1000
+    _WIN_ERROR_INVALID_PARAMETER: Final[int] = 87
+    _WIN_INHERIT_HANDLE: Final[bool] = False
+
+    def process_alive(pid: int) -> bool:
+        """Whether a process with this PID exists, treating an access denial as proof it does."""
+        handle = _KERNEL32.OpenProcess(_WIN_SYNCHRONIZE, _WIN_INHERIT_HANDLE, pid)
+        if handle:
+            _KERNEL32.CloseHandle(handle)
+            return True
+        return ctypes.get_last_error() != _WIN_ERROR_INVALID_PARAMETER
+
+    def process_start_token(pid: int) -> int | None:
+        """The process creation FILETIME as a 100ns tick count, or ``None`` when it cannot be read."""
+        handle = _KERNEL32.OpenProcess(_WIN_PROCESS_QUERY_LIMITED_INFORMATION, _WIN_INHERIT_HANDLE, pid)
+        if not handle:
+            return None
+        creation, exit_time, kernel_time, user_time = (wintypes.FILETIME() for _ in range(4))
+        try:
+            if not _KERNEL32.GetProcessTimes(
+                handle,
+                ctypes.byref(creation),
+                ctypes.byref(exit_time),
+                ctypes.byref(kernel_time),
+                ctypes.byref(user_time),
+            ):
+                return None  # pragma: no cover  # win32 GetProcessTimes failure path; not reproducible on a live handle
+        finally:
+            _KERNEL32.CloseHandle(handle)
+        return (creation.dwHighDateTime << 32) | creation.dwLowDateTime
+
+else:  # pragma: win32 no cover
+
+    def process_alive(pid: int) -> bool:
+        """Whether a process with this PID exists, treating an access denial (``EPERM``) as proof it does."""
+        try:
+            os.kill(pid, 0)
+        except OSError as error:
+            if error.errno == ESRCH:
+                return False
+            if error.errno == EPERM:
+                return True
+            raise
+        return True
+
+    if sys.platform in {"linux", "android"}:  # pragma: linux cover
+        # Termux/Android reports sys.platform == "android" but runs the Linux kernel, so /proc/<pid>/stat and the boot
+        # id are the same reliable start-time source; treat it exactly like Linux rather than the tokenless fallback.
+        # comm (field 2) is wrapped in parentheses and may itself contain spaces or a ')', so the fixed fields start
+        # after the final ')'. starttime is field 22 overall, the twentieth of those trailing fields (index 19).
+        _STARTTIME_INDEX: Final[int] = 19
+
+        def _read_boot_id() -> int:
+            # starttime is measured in clock ticks since boot, so on its own it repeats across a reboot. Folding the
+            # boot id into the high bits makes the Linux token reboot-safe like the absolute clocks macOS and Windows
+            # expose, while staying a single integer so a 3.29 reader still parses the third marker line. 0 when this
+            # process cannot read the boot id leaves the bare starttime, which _same_start compares alone.
+            try:
+                boot_id = Path("/proc/sys/kernel/random/boot_id").read_text(encoding="ascii")
+                return int(boot_id.strip().replace("-", ""), 16)
+            except (OSError, ValueError):
+                return 0
+
+        _BOOT_ID: Final[int] = _read_boot_id()
+        #: ``TIME_NS_INIT_INO`` in ``linux/proc_ns.h``, fixed by the kernel ABI like the initial PID namespace's inode.
+        _INITIAL_TIME_NAMESPACE: Final[int] = 0xEFFFFFFA
+
+        def process_start_token(pid: int) -> int | None:
+            """
+            The ``/proc/<pid>/stat`` ``starttime`` folded with the boot id.
+
+            ``None`` when the process is gone, or when this process runs in a time namespace with a boottime offset.
+            Since Linux 5.6 the kernel shifts ``starttime`` by the reader's offset, so a value read there differs
+            from what a peer outside reads.
+            """
+            return _read_start_token(pid) if _starttime_unshifted() else None
+
+        def _starttime_unshifted() -> bool:
+            # setns can move this process into another time namespace, so ask on every read.
+            try:
+                namespace: Final = Path("/proc/self/ns/time").stat().st_ino
+            except FileNotFoundError:  # no entry means no time namespaces on this kernel
+                return True
+            except OSError:  # any other failure leaves the namespace unknown, so starttime is not comparable
+                return False
+            if namespace == _INITIAL_TIME_NAMESPACE:
+                return True
+            # A container runtime may give each container a time namespace without offsets. timens_offsets describes
+            # the namespace this process's children get, its own unless it unshared one since.
+            try:
+                if Path("/proc/self/ns/time_for_children").stat().st_ino != namespace:
+                    return False
+                offsets: Final = Path("/proc/self/timens_offsets").read_text(encoding="ascii")
+            except OSError:
+                return False
+            # The clock goes by name since Linux 5.8 and by clock id before.
+            return any(line.split() in (["boottime", "0", "0"], ["7", "0", "0"]) for line in offsets.splitlines())
+
+        def _read_start_token(pid: int) -> int | None:
+            try:
+                data = Path(f"/proc/{pid}/stat").read_bytes()
+            except OSError:
+                return None
+            # psutil identifies a process by the same (pid, starttime) pair; the boot id extends that across reboots.
+            fields = data[data.rfind(b")") + 1 :].split()
+            if len(fields) <= _STARTTIME_INDEX:  # pragma: no cover  # a truncated /proc read, never seen in practice
+                return None
+            try:
+                starttime = int(fields[_STARTTIME_INDEX])
+            except ValueError:  # pragma: no cover  # /proc always renders starttime as an integer
+                return None
+            return (_BOOT_ID << 64) | starttime
+
+        def _owner_runs_elsewhere(pid: int, start_token: int | None) -> bool:
+            """
+            Whether the owner runs in another PID namespace as *pid*.
+
+            An older release in a container sharing this hostname recorded its in-container PID, which means nothing
+            here. Readers without a boottime offset read the same starttime and boot id. A task with the recorded
+            start token whose innermost PID is *pid* is therefore the owner; one that started in the same tick is not.
+            A reader with an offset cannot compare start tokens, so the innermost PID alone keeps the marker.
+            """
+            if start_token is None or (_BOOT_ID and start_token >> 64 not in {0, _BOOT_ID}):
+                return False
+            unshifted: Final = _starttime_unshifted()
+            try:
+                with os.scandir("/proc") as entries:
+                    return any(
+                        entry.name.isdigit()
+                        and (task := int(entry.name)) != pid
+                        and (
+                            not unshifted
+                            or ((token := _read_start_token(task)) is not None and _same_start(token, start_token))
+                        )
+                        and _innermost_pid(task) == pid
+                        for entry in entries
+                    )
+            except OSError:
+                # A /proc this process cannot list proves nothing either way, which leaves 4.0.12's verdict.
+                return False
+
+        def _innermost_pid(task: int) -> int | None:
+            try:
+                status: Final = Path(f"/proc/{task}/status").read_bytes()
+            except OSError:  # pragma: no cover  # the task exited between the stat read and this one
+                return None
+            # The kernel ends a line only with "\n". A task names itself, and its Name line keeps "\r", "\v" and the
+            # other separators that a text-mode read and str.splitlines() split at. A name could then forge a line.
+            return next(
+                (int(line.split()[-1]) for line in status.split(b"\n") if line.startswith(b"NSpid:")),
+                None,  # kernels before 4.1 record no namespace PIDs
+            )
+
+    elif sys.platform == "darwin":  # pragma: darwin cover
+        import ctypes
+        import struct
+
+        _LIBC: Final[ctypes.CDLL] = ctypes.CDLL(None, use_errno=True)
+        _CTL_KERN: Final[int] = 1
+        _KERN_PROC: Final[int] = 14
+        _KERN_PROC_PID: Final[int] = 1
+        # kinfo_proc opens with kp_proc.p_starttime (a struct timeval) at offset 0: int64 seconds, int32 microseconds.
+        # The offset is fixed by the struct chain kinfo_proc -> extern_proc -> p_un, so a read at 0 is not a guess.
+        _TIMEVAL_AT_ZERO: Final[str] = "<qi"
+        _TIMEVAL_SIZE: Final[int] = struct.calcsize(_TIMEVAL_AT_ZERO)
+
+        def process_start_token(pid: int) -> int | None:
+            """The process start time in microseconds from ``sysctl(KERN_PROC_PID)``, or ``None`` when it is gone."""
+            mib = (ctypes.c_int * 4)(_CTL_KERN, _KERN_PROC, _KERN_PROC_PID, pid)
+            length = ctypes.c_size_t(0)
+            # The size probe reports the kinfo_proc size for any PID, so the read below, not the probe, tells a live
+            # process from a gone one: a gone PID leaves the fetch a zero-length success, so re-check the length after.
+            if _LIBC.sysctl(mib, 4, None, ctypes.byref(length), None, 0) != 0:
+                return None
+            buffer = (ctypes.c_char * length.value)()
+            if _LIBC.sysctl(mib, 4, buffer, ctypes.byref(length), None, 0) != 0 or length.value < _TIMEVAL_SIZE:
+                return None
+            seconds, microseconds = struct.unpack_from(_TIMEVAL_AT_ZERO, buffer.raw, 0)
+            return seconds * 1_000_000 + microseconds
+
+    else:  # pragma: no cover  # a POSIX platform without a proven start-time source falls back to fail-closed liveness
+
+        def process_start_token(pid: int) -> int | None:
+            """No proven start-time source, so the owner carries no token and liveness rests on the PID alone."""
+            del pid
+            return None
+
+
+if sys.platform not in {"linux", "android"}:  # pragma: linux no cover  # pragma: android no cover
+
+    def _owner_runs_elsewhere(pid: int, start_token: int | None) -> bool:
+        """Without Linux PID namespaces, a PID that is gone or recycled leaves its owner nowhere else to run."""
+        del pid, start_token
+        return False
+
+
+__all__ = [
+    "host_name",
+    "owner_is_current_process",
+    "owner_is_stale",
+    "process_alive",
+    "process_start_token",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_lease.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_lease.py
new file mode 100644
index 0000000000000000000000000000000000000000..d328eaf4be6f35b93d81a64cc95a640ba23a63c3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_lease.py
@@ -0,0 +1,402 @@
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "contextlib",
+    "filelock._error",
+    "filelock._identity",
+    "filelock._soft",
+    "filelock._util",
+    "math",
+    "secrets",
+    "threading",
+    "weakref",
+]
+
+import os
+import secrets
+import sys
+import time
+from contextlib import suppress
+from dataclasses import dataclass
+from math import isfinite
+from threading import Event, Thread, current_thread
+from typing import TYPE_CHECKING, Final, Literal, cast
+from weakref import WeakMethod
+
+from filelock._api import _check_timeout_max, _seconds
+from filelock._error import LeaseSettingsMismatch
+from filelock._identity import owner_is_stale
+from filelock._marker import MarkerSoftFileLock, OwnerMode, OwnerRecord, parse_marker
+from filelock._soft import _read_lock_file
+from filelock._util import pin_inode, touch
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Mapping
+    from typing import Unpack
+
+    from filelock._api import LockOptions, _ExtraValue
+
+#: ``evicted`` is a :class:`~filelock.SoftReadWriteLock` loss: a peer waited out the stale threshold and committed a
+#: generation without this holder.
+CompromiseReason = Literal["marker-missing", "owner-changed", "refresh-failed", "evicted"]
+
+_RefreshOutcome = Literal["ok", "transient", "marker-missing", "owner-changed"]
+_DEFAULT_LEASE_DURATION: Final[float] = 30.0
+
+
+@dataclass(frozen=True)
+class LeaseCompromise:
+    """Why a held lease stopped being this process's to hold, and the error that ended its refresh, if any."""
+
+    lock_file: str
+    token: str
+    reason: CompromiseReason
+    error: Exception | None = None
+
+
+@dataclass(frozen=True)
+class _Heartbeat:
+    """A running heartbeat and the event that stops it, which only ever exist together."""
+
+    thread: Thread
+    stop: Event
+
+
+@dataclass
+class _LeaseClaim:
+    """The state of one claim: its token, its heartbeat, and how that claim was lost."""
+
+    token: str | None = None
+    compromise: LeaseCompromise | None = None
+    heartbeat: _Heartbeat | None = None
+
+
+class SoftFileLease(MarkerSoftFileLock):
+    """
+    Existence lock whose claim expires, so a peer may take it while the previous holder still runs.
+
+    A lease trades mutual exclusion for progress. The holder publishes a claim and refreshes it every
+    ``heartbeat_interval`` seconds; a contender takes the marker once it has seen no refresh for ``lease_duration``
+    seconds of its own monotonic clock, so clock skew between hosts cannot expire a live claim. Nothing stops the
+    expired holder: it keeps running, and it keeps using whatever the lock protects. Treat the lease as a hint about
+    who *should* be working, not as a guarantee that only one worker is.
+
+    To make a protected resource reject a superseded holder, that resource must be linearizable and must fence on a
+    monotonic generation it controls. :attr:`token` names a claim; it does not fence one. Where overlap is unacceptable,
+    use :class:`StrictSoftFileLock <filelock.StrictSoftFileLock>` instead.
+
+    Every contender for a path must agree on ``lease_duration``. A contender that finds a claim published under a
+    different duration raises :class:`LeaseSettingsMismatch <filelock.LeaseSettingsMismatch>` rather than apply its own
+    expiry to a peer that never agreed to it.
+
+    Expiry reclaims less on Windows, which refuses to rename or delete a file another process holds open. A peer there
+    takes an expired claim only once the previous holder's process exits and its handle closes; a holder that lives on
+    but stops refreshing keeps the marker. Unix reclaims the marker either way.
+
+    ``on_compromise`` fires from the heartbeat thread when a refresh fails, or when the marker vanishes or names another
+    owner. The holder should stop touching the protected resource when it runs. Because it runs on that thread, a
+    ``release()`` inside it only takes effect when the lease was built with ``thread_local=False``; the default
+    thread-local context hides the claim from every thread but the one that acquired it, so the release does nothing.
+    Signal the acquiring thread instead when the context stays thread-local.
+
+    .. versionadded:: 3.30.0
+
+    """
+
+    _owner_mode: OwnerMode = "lease"
+
+    #: lease_duration replaces the legacy age-based lifetime, so accepting both would give one lock two expiry clocks.
+    _lifetime_supported: bool = False
+    _lifetime_unsupported_reason: str = "lease_duration sets when a lease expires"
+
+    def __init__(
+        self,
+        lock_file: str | os.PathLike[str],
+        *,
+        lease_duration: float = _DEFAULT_LEASE_DURATION,
+        heartbeat_interval: float | None = None,
+        on_compromise: Callable[[LeaseCompromise], None] | None = None,
+        **kwargs: Unpack[LockOptions],
+    ) -> None:
+        """
+        Create a lease.
+
+        :param lease_duration: seconds a contender must see the marker go unrefreshed before it may take the claim.
+            Every contender for the path must pass the same value.
+        :param heartbeat_interval: seconds between refreshes. Defaults to a third of ``lease_duration``, leaving room
+            for two missed refreshes before a peer may take the claim. Must be shorter than ``lease_duration`` and at
+            most :data:`threading.TIMEOUT_MAX`.
+        :param on_compromise: called from the heartbeat thread with a :class:`LeaseCompromise` when the claim is lost.
+        :param kwargs: every other :class:`BaseFileLock <filelock.BaseFileLock>` option, ``timeout`` and ``mode`` among
+            them. The metaclass passes them all by keyword, and taking them here lets
+            :class:`AsyncSoftFileLease <filelock.AsyncSoftFileLease>` add the async plumbing a fixed signature would
+            hide.
+
+        """
+        # A plain float: the marker records its repr, which NumPy's float64 spells in a form no parser reads.
+        if not isfinite(lease_duration := _seconds("lease_duration", lease_duration)) or lease_duration <= 0:
+            msg = f"lease_duration must be positive and finite, got {lease_duration!r}"
+            raise ValueError(msg)
+        heartbeat_interval = (
+            lease_duration / 3 if heartbeat_interval is None else _seconds("heartbeat_interval", heartbeat_interval)
+        )
+        if not 0 < heartbeat_interval < lease_duration:
+            msg = f"heartbeat_interval must be positive and below lease_duration, got {heartbeat_interval!r}"
+            raise ValueError(msg)
+        _check_timeout_max("heartbeat_interval", heartbeat_interval)
+        super().__init__(lock_file, **kwargs)
+        self._lease_duration = lease_duration
+        self._heartbeat_interval = heartbeat_interval
+        self._on_compromise = on_compromise
+        # Two threads lazily creating a shared claim could each get one, and release() would miss the heartbeat's.
+        if not self.is_thread_local():
+            self._context.lease_claim = _LeaseClaim()
+
+    def _singleton_extra_mismatches(self, kwargs: Mapping[str, _ExtraValue], /) -> dict[str, tuple[str, str]]:
+        mismatches = super()._singleton_extra_mismatches(kwargs)
+        lease_duration: Final = _seconds(
+            "lease_duration", cast("float", kwargs.get("lease_duration", _DEFAULT_LEASE_DURATION))
+        )
+        if lease_duration != self._lease_duration:
+            mismatches["lease_duration"] = (str(lease_duration), str(self._lease_duration))
+        # An omitted heartbeat_interval resolves as in __init__; a differing duration is already reported above.
+        heartbeat_interval: Final = (
+            self._lease_duration / 3
+            if (passed := kwargs.get("heartbeat_interval")) is None
+            else _seconds("heartbeat_interval", cast("float", passed))
+        )
+        if heartbeat_interval != self._heartbeat_interval:
+            mismatches["heartbeat_interval"] = (str(passed), str(self._heartbeat_interval))
+        # A callback compares by identity, as on_acquired does: two equal callables can close over different state.
+        if (on_compromise := kwargs.get("on_compromise")) is not self._on_compromise:
+            mismatches["on_compromise"] = (str(on_compromise), str(self._on_compromise))
+        return mismatches
+
+    @property
+    def _claim(self) -> _LeaseClaim:
+        # Per hold, so another thread's failed acquire cannot stop the holder's heartbeat.
+        state: Final = self._hold_state()
+        if (claim := state.lease_claim) is None:
+            claim = state.lease_claim = _LeaseClaim()
+        return claim
+
+    @property
+    def lease_duration(self) -> float:
+        """The staleness in seconds after which a contender may take this claim."""
+        return self._lease_duration
+
+    @property
+    def token(self) -> str | None:
+        """
+        The token naming the claim this process published.
+
+        :returns: the token while the lease is held, ``None`` otherwise. It identifies a claim; it does not fence one.
+
+        """
+        return self._claim.token
+
+    @property
+    def compromise(self) -> LeaseCompromise | None:
+        """
+        The loss of claim the heartbeat observed.
+
+        The value outlives ``release()``, so a holder can check after leaving the ``with`` block whether its work may
+        have overlapped a successor; the next acquisition resets it, as :attr:`SoftReadWriteLock.compromise
+        <filelock.SoftReadWriteLock.compromise>` does.
+
+        :returns: the :class:`LeaseCompromise` of the latest claim, or ``None`` while that claim holds or held to its
+            release
+
+        """
+        return self._claim.compromise
+
+    def _acquire(self) -> None:
+        claim = self._claim
+        self._stop_heartbeat()  # no earlier claim's heartbeat outlives the acquisition of the next one
+        # The published record reads the token, so it exists before the marker is written and goes back on failure.
+        claim.token = token = secrets.token_hex(16)
+        claim.compromise = None
+        try:
+            super()._acquire()
+        except BaseException:
+            claim.token = None
+            raise
+        # The context is thread-local by default, so the heartbeat thread cannot read the descriptor this one just
+        # published, nor the claim this one owns. Hand it the fd, the inode it verified and the claim instead.
+        if (fd := self._context.lock_file_fd) is not None and (
+            identity := self._context.lock_file_fd_identity
+        ) is not None:
+            self._start_heartbeat(claim, fd, identity, token)
+        else:
+            claim.token = None
+
+    def _release(self) -> None:
+        self._stop_heartbeat()
+        self._claim.token = None
+        super()._release()
+
+    def _published_record(self) -> OwnerRecord:
+        return super()._published_record()._replace(token=self._claim.token, lease_duration=self._lease_duration)
+
+    def _try_break_stale_lock(self) -> None:
+        # A break can fail for reasons a contender must ride out rather than raise on: a peer broke the marker first,
+        # or Windows refuses to rename a file whose holder still has it open. Poll again instead.
+        with suppress(OSError), pin_inode(self._lock_path) as pinned:
+            self._try_break_pinned_lock(pinned)
+
+    def _try_break_pinned_lock(self, pinned: int | None) -> None:
+        if (peer := self._read_peer()) is None:
+            # Not a readable protocol 2 lease record: a partial write, a foreign or legacy protocol 1 marker, or the
+            # strict sentinel. The base self-heal evicts a genuinely malformed marker once it ages past the grace
+            # window and leaves a legitimate legacy or strict holder in place, so a corrupt marker no longer wedges
+            # every lease contender until its own timeout.
+            super()._try_break_stale_lock()
+            return
+        owner, marker = peer
+        if pinned not in {None, marker.st_ino}:  # pragma: win32 no cover  # Windows pins nothing
+            return  # replaced before the read, so nothing keeps the number read from reuse
+        # Only a peer that published a lease agreed to be superseded by age; an exclusive owner is reclaimed only once
+        # it is provably dead, and a contract this version does not know never is. Raise the mismatch outside the read
+        # so the suppression cannot swallow it.
+        if owner.mode == "lease" and owner.lease_duration != self._lease_duration:
+            msg = (
+                f"{self.lock_file} holds a lease of {owner.lease_duration!r}s but this contender configured "
+                f"{self._lease_duration!r}s; every contender for a path must agree on lease_duration"
+            )
+            raise LeaseSettingsMismatch(msg)
+        # A dead or recycled owner is reclaimed at once, whether it held a lease or an exclusive marker; a live lease
+        # owner whose marker stops being refreshed is superseded on the schedule every contender agreed to.
+        if owner.mode != "unknown" and owner_is_stale(owner.pid, owner.hostname, owner.start):
+            self._take_over(marker, owner.pid)
+            return
+        if owner.mode == "lease" and self._marker_unchanged_for(marker) >= self._lease_duration:
+            self._take_over(marker, None)
+
+    def _read_peer(self) -> tuple[OwnerRecord, os.stat_result] | None:
+        with suppress(OSError, ValueError):
+            content, marker = _read_lock_file(self._lock_path)
+            if (owner := parse_marker(content)) is not None:
+                return owner, marker
+        return None
+
+    def _start_heartbeat(self, claim: _LeaseClaim, fd: int, identity: tuple[int, int], token: str) -> None:
+        # The thread watches the event it was handed rather than whatever the claim names later: a heartbeat that
+        # outlives its join timeout would otherwise adopt the next acquisition's event and never stop.
+        stop: Final = Event()
+        loop: Final = _RefreshLoop(
+            # A strong reference from a running thread would keep a dropped lease alive, so __del__ would never release
+            # it and its marker would outlive the process. The callback stops a heartbeat that __del__ could not reach.
+            report=WeakMethod(self._report_compromise, lambda _: stop.set()),
+            lock_file=self._lock_path,
+            claim=claim,
+            fd=fd,
+            identity=identity,
+            token=token,
+            stop=stop,
+            interval=self._heartbeat_interval,
+            duration=self._lease_duration,
+        )
+        thread: Final = Thread(target=loop.run, name=f"filelock-lease-{os.getpid()}", daemon=True)
+        # Record the heartbeat before starting the thread so a release racing this acquire on a shared,
+        # non-thread-local claim always sees it and sets the stop event; the thread then exits at its first wait
+        # instead of outliving the release. A start that raises leaves the unstarted thread for _stop_heartbeat.
+        claim.heartbeat = _Heartbeat(thread, stop)
+        thread.start()
+
+    def _stop_heartbeat(self) -> None:
+        claim = self._claim
+        if (heartbeat := claim.heartbeat) is None:
+            return
+        heartbeat.stop.set()
+        claim.heartbeat = None
+        # An unstarted thread has nothing to join, on_compromise may release from the heartbeat thread itself, and
+        # during finalization a daemon thread is frozen, so joining it raises PythonFinalizationError (3.14+).
+        if heartbeat.thread.ident is not None and heartbeat.thread is not current_thread() and not sys.is_finalizing():
+            heartbeat.thread.join(timeout=self._heartbeat_interval)
+
+    def _report_compromise(
+        self,
+        claim: _LeaseClaim,
+        reason: CompromiseReason,
+        error: OSError | None,
+        token: str,
+    ) -> None:
+        # Record it on the claim this heartbeat serves, not on self._claim: a thread-local claim read from the
+        # heartbeat thread is a different, empty one, so the holder would never see the loss it is being told about.
+        # The token is the one this thread published, not claim.token, which a release may already have cleared.
+        claim.compromise = LeaseCompromise(lock_file=self.lock_file, token=token, reason=reason, error=error)
+        if self._on_compromise is not None:
+            self._on_compromise(claim.compromise)
+
+
+@dataclass(frozen=True)
+class _RefreshLoop:
+    """What a heartbeat thread needs to refresh one claim, holding the lease itself only weakly."""
+
+    report: WeakMethod[Callable[[_LeaseClaim, CompromiseReason, OSError | None, str], None]]
+    lock_file: str
+    claim: _LeaseClaim
+    fd: int
+    identity: tuple[int, int]
+    token: str
+    stop: Event
+    interval: float
+    duration: float
+
+    def run(self) -> None:
+        # A transient error (ESTALE / EIO on the NFS-style filesystems a lease targets) is not a loss. Like restic, call
+        # the claim unrefreshable once failures run long enough that a contender could take it before the next success.
+        last_success, missing = time.monotonic(), False
+        while not self.stop.wait(self.interval):
+            outcome, error = self._refresh()
+            if outcome == "ok":
+                last_success, missing = time.monotonic(), False
+                continue
+            # A peer's stale break exchanges a live marker aside for the length of its check, so only a second miss or
+            # change in a row is a loss.
+            if outcome in {"marker-missing", "owner-changed"} and not missing:
+                missing = True
+                continue
+            if outcome == "transient" and time.monotonic() - last_success < self.duration - self.interval:
+                continue
+            if (report := self.report()) is not None:
+                report(self.claim, "refresh-failed" if outcome == "transient" else outcome, error, self.token)
+            return
+
+    def _refresh(self) -> tuple[_RefreshOutcome, OSError | None]:
+        try:
+            st = os.lstat(self.lock_file)
+        except FileNotFoundError as error:
+            return self._refresh_unnamed(error)
+        except OSError as error:
+            return "transient", error
+        # A peer that took the expired claim replaced the marker, so the pathname now names its inode, not ours.
+        if (st.st_dev, st.st_ino) != self.identity:
+            return "owner-changed", None
+        return self._touch()
+
+    def _refresh_unnamed(self, name_error: FileNotFoundError) -> tuple[_RefreshOutcome, OSError | None]:
+        # A renamed directory takes the marker with it; the name is gone but the inode behind the descriptor keeps its
+        # link.
+        try:
+            linked = os.fstat(self.fd).st_nlink > 0
+        except OSError as error:
+            return "transient", error
+        if not linked:
+            return "marker-missing", name_error
+        return self._touch()
+
+    def _touch(self) -> tuple[_RefreshOutcome, OSError | None]:
+        try:
+            touch(self.lock_file, fd=self.fd)
+        except OSError as error:
+            return "transient", error
+        return "ok", None
+
+
+__all__ = [
+    "CompromiseReason",
+    "LeaseCompromise",
+    "SoftFileLease",
+    "_LeaseClaim",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_marker.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_marker.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a7c694c5382de3b2235c62feb24bac25fd9c497
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_marker.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["contextlib", "filelock._identity", "filelock._util", "math"]
+
+import math
+import os
+import re
+from contextlib import suppress
+from typing import Final, Literal, NamedTuple
+
+from filelock._identity import host_name, owner_is_current_process, owner_is_stale, process_start_token
+from filelock._soft import SoftFileLock, _read_lock_file, parse_decimal
+from filelock._util import pin_inode, write_all
+
+#: Protocol 1 is the legacy ``<pid>\n<hostname>\n[<start_token>\n]`` marker that :class:`SoftFileLock` still writes.
+#: Protocol 2 carries the owner mode and the lease claim. A protocol 1 reader treats a protocol 2 marker as malformed
+#: and evicts it after its grace period, so the two never guarantee mutual exclusion against each other.
+_PROTOCOL: Final[str] = "filelock/2"
+
+_MAX_PID: Final[int] = 2**31 - 1
+
+#: The forms ``repr`` gives a non-negative finite float or int; ``float()`` would also accept whitespace, underscores
+#: and non-ASCII digits.
+_DURATION: Final[re.Pattern[str]] = re.compile(r"[0-9]+(?:\.[0-9]+)?(?:e[+-][0-9]+)?", re.ASCII)
+
+#: Preserve unknown contracts so contenders cannot mistake them for malformed, reclaimable markers.
+OwnerMode = Literal["lease", "exclusive", "unknown"]
+
+
+class MarkerSoftFileLock(SoftFileLock):
+    """An existence lock whose marker carries a protocol 2 owner record."""
+
+    #: Age-based expiry requires a lease contract; an exclusive holder grants none.
+    _owner_mode: OwnerMode = "exclusive"
+
+    @property
+    def owner(self) -> OwnerRecord | None:
+        """
+        The owner named by the marker on disk.
+
+        :returns: the published record, or ``None`` when no marker exists or its record is malformed or protocol 1
+
+        """
+        return self._read_owner()
+
+    @property
+    def pid(self) -> int | None:
+        """
+        The PID of the process holding this lock, read from the marker.
+
+        :returns: the PID, or ``None`` when no marker exists or its record is unreadable
+
+        """
+        return None if (owner := self._read_owner()) is None else owner.pid
+
+    @property
+    def is_lock_held_by_us(self) -> bool:
+        """
+        Whether the marker on disk names this process.
+
+        :returns: ``True`` when the marker names this process's PID, hostname and, when recorded, start token
+
+        """
+        owner = self._read_owner()
+        return owner is not None and owner_is_current_process(owner.pid, owner.hostname, owner.start)
+
+    def force_break(self) -> None:
+        """
+        Remove the marker whoever holds it, so a later contender can acquire.
+
+        Forced breaking voids mutual exclusion: the previous holder keeps running and keeps using whatever the lock
+        protects. Reserve it for an operator clearing a marker whose holder is known to be gone.
+        """
+        self.break_lock()
+
+    def _try_break_stale_lock(self) -> None:
+        with suppress(OSError, ValueError), pin_inode(self._lock_path) as pinned:
+            content, marker = _read_lock_file(self._lock_path)
+            owner: Final[OwnerRecord | None]
+            if pinned not in {None, marker.st_ino}:  # pragma: win32 no cover  # Windows pins nothing
+                return  # replaced before the read, so nothing keeps the number read from reuse
+            if (owner := parse_marker(content)) is None:
+                super()._try_break_stale_lock()
+            elif owner.mode != "unknown" and owner_is_stale(owner.pid, owner.hostname, owner.start):
+                self._take_over(marker, owner.pid)
+
+    @classmethod
+    def _recorded_holder(cls, content: str | None) -> tuple[int, str] | None:
+        if (owner := parse_marker(content)) is not None:
+            return owner.pid, owner.hostname
+        return super()._recorded_holder(content)
+
+    @classmethod
+    def _marker_is_live(cls, content: str | None, breaker_pid: int) -> bool:  # pragma: win32 no cover
+        if (owner := parse_marker(content)) is None:
+            return super()._marker_is_live(content, breaker_pid)
+        return owner.mode == "unknown" or (
+            (owner.pid != breaker_pid or owner.hostname != host_name())
+            and not owner_is_stale(owner.pid, owner.hostname, owner.start)
+        )
+
+    def _read_owner(self) -> OwnerRecord | None:
+        with suppress(OSError, ValueError):
+            return parse_marker(_read_lock_file(self._lock_path)[0])
+        return None
+
+    def _write_lock_info(self, fd: int) -> None:
+        write_all(fd, encode_marker(self._published_record()))
+
+    def _published_record(self) -> OwnerRecord:
+        return OwnerRecord(
+            pid=os.getpid(),
+            hostname=host_name(),
+            mode=self._owner_mode,
+            start=process_start_token(os.getpid()),
+        )
+
+
+class OwnerRecord(NamedTuple):
+    """Keep optional metadata when reading unknown lock modes."""
+
+    pid: int
+    hostname: str
+    mode: OwnerMode
+    token: str | None = None
+    lease_duration: float | None = None
+    start: int | None = None
+
+
+def encode_marker(record: OwnerRecord) -> bytes:
+    """Render an owner record as the bytes a protocol 2 marker holds."""
+    lines = [_PROTOCOL, f"pid={record.pid}", f"host={record.hostname}", f"mode={record.mode}"]
+    if record.token is not None:
+        lines.append(f"token={record.token}")
+    if record.lease_duration is not None:
+        lines.append(f"duration={record.lease_duration!r}")
+    if record.start is not None:
+        lines.append(f"start={record.start}")
+    return "".join(f"{line}\n" for line in lines).encode()
+
+
+def parse_marker(content: str | None) -> OwnerRecord | None:
+    """Return the owner a protocol 2 marker names, or ``None`` when the record is malformed or protocol 1."""
+    # A torn write may end in a prefix like "mode=exclu", an unknown contract nobody reclaims; malformed, it ages out.
+    if not content or content[-1] != "\n" or not (lines := content.strip().splitlines()) or lines[0] != _PROTOCOL:
+        return None
+    fields: dict[str, str] = {}
+    for line in lines[1:]:
+        key, separator, value = line.partition("=")
+        if not separator:
+            return None
+        fields[key] = value
+    return _build_record(fields)
+
+
+def _build_record(fields: dict[str, str]) -> OwnerRecord | None:
+    # An unknown key is a field a newer filelock published, so ignore it rather than read the record as malformed. An
+    # unrecognized mode is the same story one level up: a contract this version does not implement. Reading it as
+    # malformed would age the marker out of a live owner's hands, so keep it and let the caller refuse to reclaim it.
+    # A record naming no mode at all states no contract and stays malformed.
+    if (published := fields.get("mode")) is None:
+        return None
+    mode: Final[OwnerMode] = published if published in {"lease", "exclusive"} else "unknown"
+    hostname = fields.get("host")
+    if not hostname or "pid" not in fields or ("duration" in fields and not _DURATION.fullmatch(fields["duration"])):
+        return None
+    try:
+        pid = parse_decimal(fields["pid"])
+        duration = float(fields["duration"]) if "duration" in fields else None
+        start = parse_decimal(fields["start"]) if "start" in fields else None
+    except ValueError:
+        return None
+    if not 1 <= pid <= _MAX_PID:
+        return None
+    token = fields.get("token")
+    # "1e400" passes the grammar but overflows to inf, which mismatches every configured duration and so wedges reclaim,
+    # where a malformed marker ages out.
+    if mode == "lease" and (not token or duration is None or not (math.isfinite(duration) and duration > 0)):
+        return None
+    return OwnerRecord(pid=pid, hostname=hostname, mode=mode, token=token, lease_duration=duration, start=start)
+
+
+__all__ = [
+    "MarkerSoftFileLock",
+    "OwnerMode",
+    "OwnerRecord",
+    "encode_marker",
+    "parse_marker",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_read_write.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_read_write.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc377d558d59fdd9115aff6ef1cee8ee239b997f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_read_write.py
@@ -0,0 +1,1504 @@
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "collections",
+    "filelock._error",
+    "filelock._identity",
+    "hashlib",
+    "itertools",
+    "pathlib",
+    "secrets",
+    "tempfile",
+]
+
+import hashlib
+import logging
+import os
+import pathlib
+import secrets
+import sqlite3
+import stat
+import sys
+import tempfile
+import threading
+import time
+from collections import deque
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass, field
+from itertools import count
+from typing import TYPE_CHECKING, ClassVar, Final, Literal, NamedTuple, TypeAlias, cast
+from weakref import WeakValueDictionary
+
+from filelock._api import (
+    AcquireReturnProxy,
+    _acquire_thread_lock,
+    _canonical,
+    _ensure_current_process,
+    _fork_transition,
+    _raise_chained_errors,
+    _register_fork_class,
+    _register_fork_object,
+    _register_owned_descriptor,
+    _resolve_lazy_imports_before_shutdown,
+    _resolve_read_write_timeout,
+    _seconds,
+    _timeout_behavior,
+    _unregister_owned_descriptor,
+)
+from filelock._error import Timeout
+from filelock._identity import host_name, owner_is_stale, process_start_token
+
+if sys.platform == "win32":  # pragma: win32 cover
+    from filelock._windows import (
+        _directory_is_private,
+        _identity_at,
+        _identity_of_fd,
+        _make_private_directory,
+        _open_non_reparse_fd,
+        _pinned,
+    )
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+    from typing import Self
+
+    from _typeshed import Unused
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("filelock")
+_GETPID: Final[Callable[[], int]] = os.getpid
+_IS_PYPY: Final[bool] = sys.implementation.name == "pypy"
+_NEEDS_CONNECTION_ESCROW: Final[bool] = (
+    hasattr(os, "register_at_fork") and sys.implementation.name == "cpython" and sys.version_info < (3, 12)
+)
+_ConnectionParameter: TypeAlias = (
+    str | bytes | os.PathLike[str] | os.PathLike[bytes] | float | int | type[sqlite3.Connection] | None
+)
+_DatabaseIdentity: TypeAlias = tuple[int, int]
+
+# sqlite3_busy_timeout() accepts a C int, max 2_147_483_647 on 32-bit. Use a lower value to be safe (~23 days).
+_MAX_SQLITE_TIMEOUT_MS: Final[int] = 2_000_000_000 - 1
+# How long a wait that its caller may abandon runs before it checks whether it should stop.
+_CANCEL_POLL_INTERVAL: Final[float] = 0.1
+_UNSAFE_FORK_EXIT_STATUS: Final[int] = 70
+#: The longest a contended acquisition waits for the database inside one fork transition, in seconds.
+_MAX_TRANSITION_WAIT: Final[float] = 0.05
+# O_NONBLOCK keeps an open from blocking on a FIFO planted at the path; the regular-file check then rejects it.
+_DB_OPEN_FLAGS: Final[int] = os.O_RDWR | os.O_CREAT | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
+_DIRECTORY_FLAGS: Final[int] = os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | getattr(os, "O_NOFOLLOW", 0)
+# Header bytes 18 and 19 hold the file format versions, 2 in WAL mode: https://www.sqlite.org/fileformat.html
+_SQLITE_MAGIC: Final[bytes] = b"SQLite format 3\x00"
+_FORMAT_VERSIONS: Final[slice] = slice(18, 20)
+_HEADER_SIZE: Final[int] = 20
+_WAL_FORMAT_VERSION: Final[int] = 2
+
+
+class _SQLiteTransitionContext(threading.local):
+    depth: int = 0
+
+
+_SQLITE_TRANSITION_CONTEXT: Final = _SQLiteTransitionContext()
+
+
+class _ConnectionEscrow:
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._functions: tuple[Callable[[sqlite3.Connection], None], Callable[[sqlite3.Connection], None]] | None = None
+
+    def functions(
+        self,
+    ) -> tuple[Callable[[sqlite3.Connection], None], Callable[[sqlite3.Connection], None]] | None:
+        if not _NEEDS_CONNECTION_ESCROW:
+            return None  # pragma: >=3.12 cover
+        with self._lock:  # pragma: <3.12 cover  # pragma: needs fork
+            if self._functions is None:
+                import ctypes  # ruff:ignore[import-outside-top-level]  # keep optional ctypes and its audited dlsym out of ordinary imports
+
+                function_type = ctypes.PYFUNCTYPE(None, ctypes.py_object)
+                increment_address = ctypes.cast(ctypes.pythonapi.Py_IncRef, ctypes.c_void_p).value
+                decrement_address = ctypes.cast(ctypes.pythonapi.Py_DecRef, ctypes.c_void_p).value
+                if increment_address is None or decrement_address is None:  # pragma: no cover - resolved CPython API
+                    msg = "CPython reference functions have no address"
+                    raise RuntimeError(msg)
+                self._functions = (
+                    cast("Callable[[sqlite3.Connection], None]", function_type(increment_address)),
+                    cast("Callable[[sqlite3.Connection], None]", function_type(decrement_address)),
+                )
+            return self._functions
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        self._lock = threading.RLock()
+
+
+_CONNECTION_ESCROW: Final = _ConnectionEscrow()
+
+
+class _ForkedDatabaseRegistry:
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._paths: set[pathlib.Path] = set()
+        self._identities: set[_DatabaseIdentity] = set()
+        self._sqlite_used = False
+        self._all_paths_poisoned = False
+
+    def raise_if_poisoned(self, path: pathlib.Path) -> None:
+        identity = self.identity(path)
+        with self._lock:
+            all_paths_poisoned = self._all_paths_poisoned
+            poisoned = (
+                all_paths_poisoned or path in self._paths or (identity is not None and identity in self._identities)
+            )
+        if poisoned:  # pragma: needs fork
+            msg = (
+                "ReadWriteLock is unavailable in a PyPy fork child; exec or exit before using it"
+                if all_paths_poisoned
+                else f"SQLite database {path!s} was active across fork(); exec or exit before using it in the child"
+            )
+            raise RuntimeError(msg)
+
+    def poison_after_fork(self, path: pathlib.Path, identity: _DatabaseIdentity | None) -> None:
+        self._paths.add(path)
+        if identity is not None:
+            self._identities.add(identity)
+
+    def note_sqlite_use(self) -> None:
+        if _IS_PYPY:
+            with self._lock:
+                self._sqlite_used = True
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        self._lock = threading.RLock()
+        self._all_paths_poisoned = self._all_paths_poisoned or (_IS_PYPY and self._sqlite_used)
+        self._sqlite_used = False
+
+    @staticmethod
+    def identity(path: pathlib.Path) -> _DatabaseIdentity | None:
+        try:
+            stat_result = path.stat()
+        except OSError:
+            return None
+        return stat_result.st_dev, stat_result.st_ino
+
+
+_FORKED_DATABASES: Final = _ForkedDatabaseRegistry()
+
+_LINK_PREFIX: Final[str] = ".filelock-"
+_LINK_NAME: Final[str] = "lock.db"
+_SWEPT_DATABASES: Final[set[_DatabaseIdentity]] = set()
+
+
+# POSIX locks belong to the process and the inode, so closing any descriptor on the inode drops the locks every other
+# connection of this process holds there. SQLite defers its own closes for this reason (section 2.2 of
+# https://www.sqlite.org/howtocorrupt.html); the probes stay open until the last connection on their inode closes.
+class _ProbeDescriptors:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._inodes: dict[_DatabaseIdentity, _InodeProbes] = {}
+        self._releases: deque[_Probe] = deque()
+        self._leases = count()
+
+    def adopt(self, database: str, claimed: list[_Probe]) -> _Probe | None:  # pragma: win32 no cover
+        # Reuse a probe no live connection holds: each connect would otherwise keep another descriptor open until the
+        # inode's last close.
+        try:
+            stat_result: Final = os.lstat(database)
+        except OSError:
+            return None
+        identity: Final = stat_result.st_dev, stat_result.st_ino
+        with self._lock:
+            if not stat.S_ISREG(stat_result.st_mode) or not (probes := self._inodes.get(identity)) or not probes.idle:
+                return None
+            claimed.append(adopted := _Probe(identity, probes.idle.pop(), next(self._leases)))
+            probes.leases.add(adopted.lease)
+        return adopted
+
+    def retain(self, fd: int, claimed: list[_Probe]) -> _Probe:  # pragma: win32 no cover
+        stat_result: Final = os.fstat(fd)
+        identity: Final = stat_result.st_dev, stat_result.st_ino
+        token: Final = _register_owned_descriptor(fd, identity)
+        with self._lock:
+            (probes := self._inodes.setdefault(identity, _InodeProbes())).descriptors.append((fd, token))
+            claimed.append(retained := _Probe(identity, fd, next(self._leases)))
+            probes.leases.add(retained.lease)
+        return retained
+
+    def release(self, probe: _Probe) -> None:  # pragma: win32 no cover
+        # A finalizer may run this on a thread already inside the lock, so it never waits; the lock holder drains.
+        self._releases.append(probe)
+        self.drain()
+
+    def drain(self) -> None:  # pragma: win32 no cover
+        while self._releases and self._lock.acquire(blocking=False):
+            try:
+                # Dequeued only once applied, so an exception leaves the rest of the release for the next drain.
+                while self._releases:
+                    self._release_locked(self._releases[0])
+                    self._releases.popleft()
+            finally:
+                self._lock.release()
+
+    def _release_locked(self, probe: _Probe) -> None:  # pragma: win32 no cover
+        if (probes := self._inodes.get(probe.identity)) is None:
+            return
+        if probe.lease in probes.leases:
+            probes.leases.remove(probe.lease)
+            if probes.leases:
+                probes.idle.append(probe.fd)
+        if probes.leases:
+            return
+        # No connect may adopt a probe about to close, even one an interrupt leaves listed.
+        probes.idle.clear()
+        # Closing under the lock keeps a concurrent connect from taking a lock on this inode before the close.
+        while probes.descriptors:
+            fd, token = probes.descriptors[-1]
+            if token is not None:  # pragma: needs fork
+                _unregister_owned_descriptor(token)
+            # Forgotten before the close: after an interrupt, a leaked descriptor beats closing a reused number.
+            probes.descriptors.pop()
+            # The descriptor is gone even when close reports an error, and no lock of this process depends on it.
+            with suppress(OSError):
+                os.close(fd)
+        del self._inodes[probe.identity]
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        # The child holds no POSIX locks, and the owned-descriptor registry closes the inherited probes.
+        self._lock = threading.Lock()
+        self._inodes = {}
+        self._releases = deque()
+
+
+class _Operation(NamedTuple):
+    pid: int
+    start_time: float
+    #: Asked between bounded waits, so an abandoned acquire stops waiting; ``None`` waits in one call.
+    cancel_check: Callable[[], bool] | None
+
+
+class _Probe(NamedTuple):
+    identity: _DatabaseIdentity
+    fd: int
+    # One per connection, so a release applied again after an interrupt kept it queued counts once.
+    lease: int
+
+
+@dataclass(slots=True)
+class _InodeProbes:
+    leases: set[int] = field(default_factory=set)
+    descriptors: list[tuple[int, int | None]] = field(default_factory=list)
+    idle: list[int] = field(default_factory=list)
+
+
+_PROBE_DESCRIPTORS: Final = _ProbeDescriptors()
+
+
+class _ForkSafeConnection(sqlite3.Connection):
+    _creator_pid: int
+    _decrement_escrow: Callable[[sqlite3.Connection], None] | None
+    _database_directory: _LinkDirectory | None
+    database_identity: _DatabaseIdentity | None = None
+    _probe: _Probe | None = None
+
+    def __new__(
+        cls,
+        *_args: _ConnectionParameter,
+        **_kwargs: _ConnectionParameter,
+    ) -> Self:
+        connection = super().__new__(cls)
+        connection._creator_pid = _GETPID()
+        connection._decrement_escrow = None
+        connection._database_directory = None
+        return connection
+
+    def close(self) -> None:
+        with _sqlite_transition():
+            if _GETPID() != self._creator_pid:  # pragma: needs fork
+                return
+            with _fork_transition():
+                sqlite3.Connection.close(self)
+                try:
+                    if (directory := self._database_directory) is not None:  # pragma: needs posix-hard-link
+                        self._database_directory = None
+                        _remove_link_directory(directory)
+                finally:
+                    if (probe := self._probe) is not None:  # pragma: win32 no cover
+                        self._probe = self.database_identity = None
+                        _PROBE_DESCRIPTORS.release(probe)
+                if (decrement := self._decrement_escrow) is not None:  # pragma: <3.12 cover  # pragma: needs fork
+                    self._decrement_escrow = None
+                    decrement(self)
+
+    def retain_link(self, directory: _LinkDirectory | None) -> None:  # pragma: win32 cover
+        """Keep the private link directory, if there is one, until SQLite no longer uses it."""
+        self._database_directory = directory
+
+    def retain_until_close(self, directory: _LinkDirectory | None, probe: _Probe) -> None:  # pragma: win32 no cover
+        """Keep the private link and this connection's probe descriptor until SQLite no longer uses them."""
+        self._database_directory = directory
+        self._probe = probe
+        self.database_identity = probe.identity
+
+    def acquire_escrow(  # pragma: <3.12 cover  # pragma: needs fork
+        self,
+        functions: tuple[Callable[[sqlite3.Connection], None], Callable[[sqlite3.Connection], None]] | None,
+    ) -> None:
+        # The caller only reaches here holding the escrow functions; it skips the call entirely without them.
+        if functions is not None:  # pragma: no branch
+            increment, decrement = functions
+            increment(self)
+            self._decrement_escrow = decrement
+
+    def __del__(self) -> None:
+        with suppress(sqlite3.Error, RuntimeError, OSError):
+            self.close()
+
+
+@dataclass(slots=True)
+class _OwnedConnection:
+    """
+    The connection of one lock, closed when the lock is collected.
+
+    CPython runs ``__del__`` before it clears weak references. A finalizer on the lock itself would close the
+    connection while the singleton cache still hands the lock out, and a thread given the lock would nest into a hold
+    with no database lock behind it. The lock alone refers to this holder, so the holder is collected once the cache no
+    longer finds the lock.
+    """
+
+    connection: _ForkSafeConnection | None = None
+
+    def __del__(self) -> None:
+        if (connection := self.connection) is not None:
+            with suppress(sqlite3.Error, RuntimeError):
+                connection.close()
+
+
+class _ReadWriteLockMeta(type):
+    """
+    Resolve singleton instances for ``is_singleton=True`` construction.
+
+    This logic lives here rather than in ReadWriteLock.get_lock so ``ReadWriteLock(path)`` returns cached instances
+    without a 2-arg ``super()`` call that type checkers cannot verify.
+
+    """
+
+    _instances: WeakValueDictionary[pathlib.Path, ReadWriteLock]
+    _instances_lock: threading.RLock
+    _instances_pid: int
+    _instances_under_construction: set[pathlib.Path]
+
+    def __call__(
+        cls,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+    ) -> ReadWriteLock:
+        _ensure_current_process()
+        _resolve_lazy_imports_before_shutdown()
+        timeout = _seconds("timeout", timeout)
+        if cls._instances_pid != _GETPID():
+            cls._reset_class_after_fork()
+        construction_pid = _GETPID()
+        if not is_singleton:
+            instance = super().__call__(lock_file, timeout, blocking=blocking, is_singleton=is_singleton)
+            if _GETPID() != construction_pid:  # pragma: forked child
+                msg = "ReadWriteLock construction cannot continue after fork"
+                raise RuntimeError(msg)
+            return instance
+
+        # Resolve only the parent, so a symlink at the lock path stays its own key instead of aliasing its target.
+        normalized = pathlib.Path(_canonical(lock_file))
+        with cls._instances_lock:
+            # One lookup, since another thread can drop the last reference between a membership check and a read.
+            if (instance := cls._instances.get(normalized)) is None:
+                if normalized in cls._instances_under_construction:  # pragma: no cover - exercised in an audit callback
+                    msg = f"Singleton lock construction is already active for {lock_file!s}"
+                    raise RuntimeError(msg)
+                construction_registry = cls._instances_under_construction
+                construction_registry.add(normalized)
+                try:
+                    instance = super().__call__(lock_file, timeout, blocking=blocking, is_singleton=is_singleton)
+                finally:
+                    if _GETPID() == construction_pid:
+                        construction_registry.discard(normalized)
+                if _GETPID() != construction_pid:
+                    msg = "ReadWriteLock construction cannot continue after fork"
+                    raise RuntimeError(msg)
+                cls._instances[normalized] = instance
+
+            if (
+                _timeout_behavior(instance.timeout, any_negative=False)
+                != _timeout_behavior(timeout, any_negative=False)
+                or instance.blocking != blocking
+            ):
+                msg = (
+                    f"Singleton lock created with timeout={instance.timeout}, blocking={instance.blocking},"
+                    f" cannot be changed to timeout={timeout}, blocking={blocking}"
+                )
+                raise ValueError(msg)
+            return instance
+
+    def _reset_class_after_fork(cls) -> None:  # pragma: forked child
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = threading.RLock()
+        cls._instances_pid = _GETPID()
+        cls._instances_under_construction = set()
+
+
+class ReadWriteLock(metaclass=_ReadWriteLockMeta):
+    """
+    Cross-process read-write lock backed by SQLite.
+
+    Allows concurrent shared readers or a single exclusive writer. The lock is reentrant within the same mode (multiple
+    ``acquire_read`` calls nest, as do multiple ``acquire_write`` calls from the same thread), but upgrading from read
+    to write or downgrading from write to read raises :class:`RuntimeError`. Write locks are pinned to the thread that
+    acquired them, and each thread sharing a read lock can release only the levels it acquired.
+
+    An instance coordinates processes, not threads: a thread asking for the opposite mode of another thread's hold
+    raises :class:`RuntimeError` instead of waiting. Threads that must wait for each other each need their own
+    instance (``is_singleton=False``).
+
+    By default, ``is_singleton=True``: calling ``ReadWriteLock(path)`` with the same resolved path returns the same
+    instance. A ``.db`` extension is a convention rather than a requirement; the filesystem must be one the active
+    SQLite VFS supports. Give the lock a file of its own: a WAL-mode database, or one with a schema larger than a lock
+    needs, raises :class:`ValueError`. A database directory that other accounts can write must also be writable by
+    this one and support hard links; the protection against other accounts ends once one of them can replace the
+    database directory or a directory above it.
+
+    :param lock_file: path to the SQLite database file used as the lock
+    :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+    :param is_singleton: if ``True``, reuse existing instances for the same resolved path
+
+    .. versionadded:: 3.21.0
+
+    """
+
+    _instances: WeakValueDictionary[pathlib.Path, ReadWriteLock] = WeakValueDictionary()
+    _instances_lock = threading.RLock()
+    _instances_pid = _GETPID()
+    _instances_under_construction: ClassVar[set[pathlib.Path]] = set()
+
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = threading.RLock()
+        cls._instances_pid = _GETPID()
+        cls._instances_under_construction = set()
+        _register_fork_class(cls)
+
+    @classmethod
+    def get_lock(
+        cls, lock_file: str | os.PathLike[str], timeout: float = -1, *, blocking: bool = True
+    ) -> ReadWriteLock:
+        """
+        Return the singleton :class:`ReadWriteLock` for *lock_file*.
+
+        :param lock_file: path to the SQLite database file used as the lock
+        :param timeout: maximum wait time in seconds; ``-1`` waits up to SQLite's busy-timeout cap of about 23 days
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: the singleton lock instance
+
+        :raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values
+
+        """
+        return cls(lock_file, timeout, blocking=blocking)
+
+    def __init__(
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,  # ruff:ignore[unused-method-argument]  # consumed by _ReadWriteLockMeta.__call__
+    ) -> None:
+        self.lock_file = os.fspath(lock_file)
+        self._canonical_path = pathlib.Path(_canonical(lock_file))
+        _FORKED_DATABASES.raise_if_poisoned(self._canonical_path)
+        self.timeout = timeout
+        self.blocking = blocking
+        self._transaction_lock = threading.Lock()  # serializes the (possibly blocking) SQLite transaction work
+        self._internal_lock = threading.Lock()  # protects _lock_level / _current_mode updates and rollback
+        self._lock_level = 0
+        self._current_mode: Literal["read", "write"] | None = None
+        self._write_thread_id: int | None = None
+        self._read_depths: dict[int, int] = {}
+        self._acquisition_thread_ids: set[int] = set()
+        self._owned_connection = _OwnedConnection()
+        self._connection_transaction_released = True
+        self._connection_identity: _DatabaseIdentity | None = None
+        self._closed = False
+        self._creator_pid = _GETPID()
+        self._fork_invalidated = False
+        _register_fork_object(self)
+        with _fork_transition(), _sqlite_transition():
+            validation_connection = self._open_connection(sqlite_timeout=5.0)
+            validation_connection.close()
+
+    def acquire_read(self, timeout: float | None = None, *, blocking: bool | None = None) -> AcquireReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acquire a
+        read lock while holding a write lock raises :class:`RuntimeError` (downgrade not allowed).
+
+        :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
+            busy-timeout cap of about 23 days
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
+            ``None`` uses the instance setting
+
+        :returns: a proxy that can be used as a context manager to release the lock
+
+        :raises RuntimeError: if a write lock is already held on this instance
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        return self._acquire(
+            "read",
+            self.timeout if timeout is None else timeout,
+            blocking=self.blocking if blocking is None else blocking,
+        )
+
+    def acquire_write(self, timeout: float | None = None, *, blocking: bool | None = None) -> AcquireReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        If this instance already holds a write lock from the same thread, the lock level is incremented (reentrant).
+        Attempting to acquire a write lock while holding a read lock raises :class:`RuntimeError` (upgrade not allowed).
+        Write locks are pinned to the acquiring thread: a different thread trying to re-enter also raises
+        :class:`RuntimeError`.
+
+        :param timeout: seconds to wait; ``None`` uses the instance setting; ``-1`` waits up to SQLite's
+            busy-timeout cap of about 23 days
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` on contention;
+            ``None`` uses the instance setting
+
+        :returns: a proxy that can be used as a context manager to release the lock
+
+        :raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        return self._acquire(
+            "write",
+            self.timeout if timeout is None else timeout,
+            blocking=self.blocking if blocking is None else blocking,
+        )
+
+    @contextmanager
+    def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> Generator[None]:
+        """
+        Context manager that acquires and releases a shared read lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        self.acquire_read(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            self.release()
+
+    @contextmanager
+    def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> Generator[None]:
+        """
+        Context manager that acquires and releases an exclusive write lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        """
+        self.acquire_write(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            self.release()
+
+    def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the current lock.
+
+        When the lock level reaches zero the underlying SQLite transaction is rolled back, releasing the database lock.
+
+        :param force: if ``True``, release the lock completely regardless of the current lock level
+
+        :raises RuntimeError: if no lock is currently held and *force* is ``False``, or if the calling thread holds
+            no level of the current lock and *force* is ``False``
+
+        """
+        with _fork_transition():
+            _ensure_current_process()
+            if self._inherited:  # pragma: needs fork
+                return
+            self._raise_if_acquiring("release")
+            self._release(force=force, close=False)
+
+    def close(self) -> None:
+        """
+        Release the lock (if held) and close the underlying SQLite connection.
+
+        After calling this method, the lock instance is no longer usable. Unlike :meth:`release`, it ends every
+        thread's hold on this instance, whichever thread calls it.
+
+        """
+        with _fork_transition():
+            _ensure_current_process()
+            if self._inherited:  # pragma: needs fork
+                return
+            self._raise_if_acquiring("close")
+            self._release(force=True, close=True)
+
+    def _acquire_level_of(
+        self,
+        holder: int,
+        mode: Literal["read", "write"],
+        timeout: float,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool],
+    ) -> AcquireReturnProxy:
+        # Records the level under *holder* instead of the calling thread: an async wrapper's executor thread does not
+        # identify the tasks it holds for. Gives up with Timeout once *cancel_check* is true.
+        return self._acquire(mode, timeout, blocking=blocking, holder=holder, cancel_check=cancel_check)
+
+    def _release_level_of(self, thread_id: int) -> None:
+        with _fork_transition():
+            _ensure_current_process()
+            self._raise_if_acquiring("release")
+            self._release(force=False, close=False, thread_id=thread_id)
+
+    def _holds_level_of(self, thread_id: int) -> bool:
+        # Read without the internal lock. The async wrapper asks from its event loop, which must not wait out a release
+        # on another thread. A stale answer is what a caller asking a moment earlier would have had. A level whose
+        # transaction ended is one an interrupted release left behind; it counts as gone, as _holds_level() treats it.
+        if thread_id != self._write_thread_id and thread_id not in self._read_depths:
+            return False
+        try:
+            return not self._transaction_ended()
+        except sqlite3.ProgrammingError:
+            # The connection closed between the read of _con and the in_transaction call, so the transaction is over.
+            return False
+
+    def _release(self, *, force: bool, close: bool, thread_id: int | None = None) -> None:
+        thread_id = threading.get_ident() if thread_id is None else thread_id
+        with self._transaction_lock, self._internal_lock:
+            if not force:
+                self._raise_if_not_holder(thread_id)
+            if self._lock_level == 0:
+                if force and self._con is None:
+                    if close:
+                        self._closed = True
+                    return
+                if not force:
+                    msg = f"Cannot release a lock on {self.lock_file} (lock id: {id(self)}) that is not held"
+                    raise RuntimeError(msg)
+            if not force and self._lock_level > 1:
+                self._leave_one_level(thread_id)
+                return
+            try:
+                self._finish_connection()
+            except BaseException:
+                # Once the rollback ran, the level is gone whatever stopped the cleanup, a signal handler's exception
+                # included. Kept, it would let the next acquire nest into a transaction that no longer exists.
+                if self._transaction_ended():
+                    self._clear_lock_state()
+                raise
+            self._clear_lock_state()
+            if close:
+                self._closed = True
+
+    def _transaction_ended(self) -> bool:
+        if self._connection_transaction_released or (connection := self._con) is None:
+            return True
+        # An interrupt can land between the rollback and the flag that records it.
+        return not connection.in_transaction
+
+    def _raise_if_not_holder(self, thread_id: int) -> None:
+        # The connection runs with check_same_thread=False, so a release from another thread would end the owner's
+        # transaction under it and let a second writer in.
+        if self._current_mode == "write" and thread_id != self._write_thread_id:
+            msg = (
+                f"Cannot release write lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {thread_id} while it is held by thread {self._write_thread_id}"
+            )
+            raise RuntimeError(msg)
+        # Readers share that one transaction too, so a thread that holds no read level would end another's hold.
+        if self._current_mode == "read" and thread_id not in self._read_depths:
+            msg = (
+                f"Cannot release read lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {thread_id}, which does not hold it"
+            )
+            raise RuntimeError(msg)
+
+    def _leave_one_level(self, thread_id: int) -> None:
+        self._lock_level -= 1
+        if self._current_mode == "read" and (depth := self._read_depths.pop(thread_id) - 1):
+            self._read_depths[thread_id] = depth
+
+    def _clear_lock_state(self) -> None:
+        self._lock_level = 0
+        self._current_mode = None
+        self._write_thread_id = None
+        self._read_depths = {}
+
+    @property
+    def _con(self) -> _ForkSafeConnection | None:
+        return self._owned_connection.connection
+
+    @_con.setter
+    def _con(self, connection: _ForkSafeConnection | None) -> None:
+        self._owned_connection.connection = connection
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        if self._con is not None:
+            _FORKED_DATABASES.poison_after_fork(self._canonical_path, self._connection_identity)
+        self._con = None
+        self._connection_transaction_released = True
+        self._connection_identity = None
+        self._transaction_lock = threading.Lock()
+        self._internal_lock = threading.Lock()
+        self._clear_lock_state()
+        self._acquisition_thread_ids = set()
+        self._fork_invalidated = True
+
+    @property
+    def _inherited(self) -> bool:
+        return self._fork_invalidated or _GETPID() != self._creator_pid
+
+    def _raise_if_unusable(self) -> None:
+        _ensure_current_process()
+        if self._inherited:  # pragma: needs fork
+            msg = f"ReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance"
+            raise RuntimeError(msg)
+        if self._closed:
+            msg = "Cannot operate on a closed database."
+            raise sqlite3.ProgrammingError(msg)
+
+    def _acquire(
+        self,
+        mode: Literal["read", "write"],
+        timeout: float,
+        *,
+        blocking: bool,
+        holder: int | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AcquireReturnProxy:
+        timeout = _resolve_read_write_timeout(timeout, blocking=blocking)
+        start_time: Final = time.monotonic()
+        remaining = timeout  # -1 waits up to SQLite's busy-timeout cap
+        while True:
+            # A fork waits for the open transitions and admits no new one meanwhile. A wait for the database inside one
+            # stalls the forking thread and, behind it, each lock call in the process. With no other thread to fork,
+            # the wait runs in one piece, which keeps SQLite's writer preference. threading does not count a
+            # thread started through _thread, so a fork from one of those still waits.
+            final = (
+                not blocking
+                or 0 <= remaining <= _MAX_TRANSITION_WAIT
+                or not hasattr(os, "register_at_fork")
+                or threading.active_count() == 1
+            )
+            try:
+                return self._attempt_acquire(
+                    mode,
+                    remaining if final else _MAX_TRANSITION_WAIT,
+                    blocking=blocking,
+                    holder=holder,
+                    cancel_check=cancel_check,
+                )
+            except Timeout:
+                if final or (cancel_check is not None and cancel_check()):
+                    raise
+            # Only a runtime with fork handlers waits in more than one attempt.
+            if timeout != -1:  # pragma: needs register-at-fork
+                remaining = max(timeout - (time.monotonic() - start_time), 0)
+
+    def _attempt_acquire(
+        self,
+        mode: Literal["read", "write"],
+        timeout: float,
+        *,
+        blocking: bool,
+        holder: int | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AcquireReturnProxy:
+        with _fork_transition():
+            self._raise_if_unusable()
+            operation_pid = _GETPID()
+            thread_id = threading.get_ident()
+            holder = thread_id if holder is None else holder
+            with self._internal_lock:
+                if self._holds_level():
+                    return self._validate_reentrant(mode, holder)
+                if thread_id in self._acquisition_thread_ids:  # pragma: no cover - exercised in an audit callback
+                    msg = f"Cannot acquire ReadWriteLock on {self.lock_file} while acquisition is active in this thread"
+                    raise RuntimeError(msg)
+                self._acquisition_thread_ids.add(thread_id)
+            try:
+                start_time = time.perf_counter()
+                self._acquire_transaction_lock(blocking=blocking, timeout=timeout, cancel_check=cancel_check)
+                try:
+                    self._raise_if_unusable()
+                    return self._do_acquire_inner(
+                        mode,
+                        timeout,
+                        holder,
+                        blocking=blocking,
+                        operation=_Operation(operation_pid, start_time, cancel_check),
+                    )
+                finally:
+                    self._transaction_lock.release()
+            finally:
+                with self._internal_lock:
+                    self._acquisition_thread_ids.discard(thread_id)
+
+    def _do_acquire_inner(
+        self,
+        mode: Literal["read", "write"],
+        timeout: float,
+        holder: int,
+        *,
+        blocking: bool,
+        operation: _Operation,
+    ) -> AcquireReturnProxy:
+        operation_pid, start_time, _ = operation
+        # Double-check: another thread may have acquired the lock while we waited on _transaction_lock.
+        with self._internal_lock:
+            if self._holds_level():
+                return self._validate_reentrant(mode, holder)
+        if self._con is not None:
+            self._finish_connection()
+        try:
+            self._open_for_acquisition(
+                timeout,
+                blocking=blocking,
+                operation_pid=operation_pid,
+                start_time=start_time,
+            )
+            self._configure_and_begin(mode, timeout, blocking=blocking, operation=operation)
+            self._raise_if_process_changed(operation_pid)
+        except BaseException as error:
+            acquisition_error: BaseException
+            if isinstance(error, sqlite3.OperationalError) and "database is locked" in str(error):
+                acquisition_error = Timeout(self.lock_file)
+            else:
+                acquisition_error = error
+            try:
+                self._finish_connection()
+            except sqlite3.Error as cleanup_error:
+                _raise_chained_errors(acquisition_error, cleanup_error)
+            if acquisition_error is not error:
+                raise acquisition_error from None
+            raise
+        with self._internal_lock:
+            self._raise_if_process_changed(operation_pid)
+            self._current_mode = mode
+            self._lock_level = 1
+            if mode == "write":
+                self._write_thread_id = holder
+            else:
+                self._read_depths = {holder: 1}
+        return AcquireReturnProxy(lock=self)
+
+    def _open_for_acquisition(self, timeout: float, *, blocking: bool, operation_pid: int, start_time: float) -> None:
+        with _sqlite_transition():
+            sqlite_timeout = (
+                timeout_for_sqlite(
+                    timeout,
+                    blocking=blocking,
+                    already_waited=time.perf_counter() - start_time,
+                )
+                / 1000
+            )
+            connection = self._open_connection(sqlite_timeout=sqlite_timeout)
+            self._con, self._connection_transaction_released, self._connection_identity = (
+                connection,
+                False,
+                _FORKED_DATABASES.identity(self._canonical_path),
+            )
+            self._raise_if_process_changed(operation_pid)
+
+    def _configure_and_begin(
+        self,
+        mode: Literal["read", "write"],
+        timeout: float,
+        *,
+        blocking: bool,
+        operation: _Operation,
+    ) -> None:
+        with _sqlite_transition():
+            connection = cast("_ForkSafeConnection", self._con)
+            # SQLite opened the file the name held at connect time, and its first statement would replay a journal
+            # beside that file, so the name is checked before any statement runs.
+            self._raise_if_database_replaced(connection)
+            with _bounded_schema(connection, self.lock_file):
+                self._raise_if_process_changed(operation.pid)
+                # Use legacy journal mode (not WAL) because WAL does not block readers while a concurrent EXCLUSIVE
+                # write transaction is active, which makes read-write locking impossible without modifying table data.
+                # MEMORY is safe here since no writes happen, so a crash cannot corrupt the DB.
+                # See https://sqlite.org/lang_transaction.html#deferred_immediate_and_exclusive_transactions
+                self._execute_waiting(
+                    connection, "PRAGMA journal_mode=MEMORY;", timeout, blocking=blocking, operation=operation
+                )
+                self._raise_if_process_changed(operation.pid)
+                statements = "BEGIN EXCLUSIVE TRANSACTION;" if mode == "write" else "BEGIN TRANSACTION;"
+                if mode == "read":
+                    # SQLite takes the SHARED lock only when a statement reads; BEGIN alone stays deferred.
+                    # https://www.sqlite.org/lockingv3.html#transaction_control
+                    # sqlite_schema is an alias added in SQLite 3.33.0; sqlite_master works on every version.
+                    statements += " SELECT name FROM sqlite_master LIMIT 1;"
+                self._execute_waiting(connection, statements, timeout, blocking=blocking, operation=operation)
+            self._raise_if_database_replaced(connection)
+
+    @staticmethod
+    def _execute_waiting(
+        connection: _ForkSafeConnection, statements: str, timeout: float, *, blocking: bool, operation: _Operation
+    ) -> None:
+        # SQLite's busy wait cannot be interrupted. An acquire its caller may abandon waits in bounded slices and asks
+        # between them whether to stop.
+        slice_ms = int(_CANCEL_POLL_INTERVAL * 1000)
+        while True:
+            busy_ms = timeout_for_sqlite(
+                timeout, blocking=blocking, already_waited=time.perf_counter() - operation.start_time
+            )
+            cancel_check = operation.cancel_check if busy_ms > slice_ms else None
+            try:
+                connection.executescript(
+                    f"PRAGMA busy_timeout={busy_ms if cancel_check is None else slice_ms}; {statements}"
+                ).close()
+            except sqlite3.OperationalError as error:
+                if cancel_check is None or "database is locked" not in str(error) or cancel_check():
+                    raise
+                # A read's BEGIN succeeds before its SELECT waits, so the retry has to start a fresh transaction.
+                if connection.in_transaction:
+                    connection.rollback()
+            else:
+                return
+
+    def _raise_if_database_replaced(self, connection: _ForkSafeConnection) -> None:
+        # Windows pins the name: SQLite opens the database without delete sharing, so it cannot be unlinked or renamed.
+        if (identity := connection.database_identity) is None:  # pragma: win32 cover
+            return
+        try:  # pragma: win32 no cover
+            current = self._canonical_path.stat(follow_symlinks=False)
+        except FileNotFoundError:  # pragma: win32 no cover
+            current = None
+        # The lock lives on the inode, so one taken after the path moved on excludes no later opener.
+        if current is None or (current.st_dev, current.st_ino) != identity:  # pragma: win32 no cover
+            msg = f"lock database {self.lock_file!r} was unlinked or replaced while acquiring; leave it in place"
+            raise OSError(msg)
+
+    def _open_connection(self, *, sqlite_timeout: float) -> _ForkSafeConnection:
+        with _sqlite_transition():
+            creator_pid = _GETPID()
+            functions = _CONNECTION_ESCROW.functions()
+            if _GETPID() != creator_pid:  # pragma: forked child
+                msg = "SQLite connection construction cannot continue after fork"
+                raise RuntimeError(msg)
+            try:
+                connection = _connect(
+                    os.fspath(self._canonical_path),
+                    factory=_ForkSafeConnection,
+                    timeout=sqlite_timeout,
+                )
+            except BlockingIOError:
+                raise Timeout(self.lock_file) from None
+            if functions is not None:  # pragma: <3.12 cover  # pragma: needs fork
+                connection.acquire_escrow(functions)
+            if _GETPID() != creator_pid:  # pragma: forked child
+                _FORKED_DATABASES.poison_after_fork(
+                    self._canonical_path,
+                    _FORKED_DATABASES.identity(self._canonical_path),
+                )
+                msg = "SQLite connection construction cannot continue after fork"
+                raise RuntimeError(msg)
+            return connection
+
+    def _finish_connection(self) -> None:
+        with _sqlite_transition():
+            if (connection := self._con) is None:
+                return
+            rollback_error: sqlite3.Error | None = None
+            if not self._connection_transaction_released:
+                if connection.in_transaction:
+                    try:
+                        connection.rollback()
+                    except sqlite3.Error as error:
+                        if connection.in_transaction:
+                            raise
+                        self._connection_transaction_released = True
+                        rollback_error = error
+                    else:
+                        self._connection_transaction_released = True
+                else:
+                    self._connection_transaction_released = True
+            try:
+                connection.close()
+            except sqlite3.Error as close_error:
+                if rollback_error is not None:
+                    _raise_chained_errors(rollback_error, close_error)
+                raise
+            self._con = None
+            self._connection_transaction_released = True
+            self._connection_identity = None
+            if rollback_error is not None:
+                raise rollback_error
+
+    def _holds_level(self) -> bool:
+        # A release interrupted after its rollback, but before it recorded that, leaves a level with no transaction.
+        if self._lock_level > 0 and self._transaction_ended():
+            self._clear_lock_state()
+        return self._lock_level > 0
+
+    def _validate_reentrant(self, mode: Literal["read", "write"], cur: int) -> AcquireReturnProxy:
+        if self._current_mode != mode:
+            opposite = "write" if mode == "read" else "read"
+            if cur == self._write_thread_id or cur in self._read_depths:
+                direction = "downgrade" if mode == "read" else "upgrade"
+                reason = f"already holding a {opposite} lock ({direction} not allowed)"
+            else:
+                reason = (
+                    f"another thread holds a {opposite} lock on this instance, which coordinates processes rather "
+                    "than threads; give each thread its own instance with is_singleton=False"
+                )
+            msg = f"Cannot acquire {mode} lock on {self.lock_file} (lock id: {id(self)}): {reason}"
+            raise RuntimeError(msg)
+        if mode == "write" and cur != self._write_thread_id:
+            msg = (
+                f"Cannot acquire write lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {cur} while it is held by thread {self._write_thread_id}"
+            )
+            raise RuntimeError(msg)
+        if mode == "read":
+            self._read_depths[cur] = self._read_depths.get(cur, 0) + 1
+        self._lock_level += 1
+        return AcquireReturnProxy(lock=self)
+
+    def _acquire_transaction_lock(
+        self, *, blocking: bool, timeout: float, cancel_check: Callable[[], bool] | None
+    ) -> None:
+        if not _acquire_thread_lock(
+            self._transaction_lock,
+            blocking=blocking,
+            timeout=timeout,
+            poll_interval=_CANCEL_POLL_INTERVAL,
+            cancel_check=cancel_check,
+        ):
+            raise Timeout(self.lock_file) from None
+
+    def _raise_if_acquiring(self, operation: Literal["acquire", "close", "release"]) -> None:
+        with self._internal_lock:
+            active_in_current_thread = threading.get_ident() in self._acquisition_thread_ids
+        if active_in_current_thread:  # pragma: no cover - exercised in an audit callback
+            msg = f"Cannot {operation} ReadWriteLock on {self.lock_file} while acquisition is active in this thread"
+            raise RuntimeError(msg)
+
+    def _raise_if_process_changed(self, operation_pid: int) -> None:
+        if _GETPID() != operation_pid or self._inherited:  # pragma: forked child
+            msg = f"ReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance"
+            raise RuntimeError(msg)
+
+
+def _connect(database: str, *, factory: type[_ForkSafeConnection], timeout: float) -> _ForkSafeConnection:
+    _FORKED_DATABASES.note_sqlite_use()
+    # A symlink at the path would make SQLite open, lock, or create its target, so connect through a descriptor that
+    # refuses one.
+    if sys.platform == "win32":  # pragma: win32 cover
+        fd: Final = _open_lock_database(database, oplock_wait=timeout)
+        link: _LinkDirectory | None = None
+        # A Windows lock belongs to the handle that took it, so closing this one leaves SQLite's locks in place.
+        try:
+            _raise_if_wal(fd, database)
+            target = database
+            if not _directory_is_private(os.fspath(pathlib.Path(database).parent)):
+                link = _link_beside_on_windows(database, _identity_of_fd(fd))
+                target = os.fspath(link.database)
+            try:
+                connection = sqlite3.connect(
+                    target, check_same_thread=False, factory=factory, cached_statements=0, timeout=timeout
+                )
+            except BaseException:
+                if link is not None:
+                    _remove_link_directory(link)
+                raise
+            connection.retain_link(link)
+            return connection
+        finally:
+            os.close(fd)
+    return _connect_through_descriptor(  # pragma: win32 no cover
+        database, factory=factory, timeout=timeout, owner=os.geteuid()
+    )
+
+
+def _connect_through_descriptor(  # pragma: win32 no cover
+    database: str, *, factory: type[_ForkSafeConnection], timeout: float, owner: int
+) -> _ForkSafeConnection:
+    # Listed before its lease is taken and cleared once a connection owns it, so any exception between, an interrupt
+    # included, releases the lease instead of pinning the inode's probes.
+    claimed: Final[list[_Probe]] = []
+    link: _LinkDirectory | None = None
+    try:
+        if (probe := _PROBE_DESCRIPTORS.adopt(database, claimed)) is None:
+            probe = _PROBE_DESCRIPTORS.retain(_open_lock_database(database), claimed)
+        identity, fd, _ = probe
+        # Releases a finalizer queued while the table was locked.
+        _PROBE_DESCRIPTORS.drain()
+        _raise_if_wal(fd, database)
+        target = database
+        # SQLite opens the name it is given, following symlinks, and uses the -journal, -wal and -shm names beside it,
+        # so the database name is safe only where no process of another account can create names. A descriptor path
+        # such as /proc/self/fd/<n> is no better: SQLite reads it back into the name the kernel reports.
+        if not _names_are_private(pathlib.Path(database).parent, owner):  # pragma: needs posix-hard-link
+            link = _link_beside(database, identity, owner)
+            target = os.fspath(link.database)
+        connection = sqlite3.connect(
+            target, check_same_thread=False, factory=factory, cached_statements=0, timeout=timeout
+        )
+        connection.retain_until_close(link, probe)
+        claimed.clear()
+        return connection
+    finally:
+        for unowned in claimed:
+            _PROBE_DESCRIPTORS.release(unowned)
+        if claimed and link is not None:  # pragma: needs posix-hard-link
+            # A connection that already took the link removes it too when it closes.
+            _remove_link_directory(link)
+
+
+def _names_are_private(directory: pathlib.Path, owner: int) -> bool:  # pragma: win32 no cover
+    status: Final = os.lstat(directory)
+    # The sticky bit still lets others create names, so a directory anyone else may write to never qualifies.
+    return status.st_uid in {owner, 0} and not status.st_mode & (stat.S_IWGRP | stat.S_IWOTH)
+
+
+class _LinkDirectory(NamedTuple):  # pragma: needs posix-hard-link
+    path: pathlib.Path
+    identity: _DatabaseIdentity
+    # Made through a descriptor of path, which nobody else can list, so a directory another process swaps in under
+    # path cannot hold this name and SQLite fails to open instead of following the swap.
+    name: str
+
+    @property
+    def database(self) -> pathlib.Path:
+        return self.path / self.name / _LINK_NAME
+
+
+def _link_beside(  # pragma: needs posix-hard-link
+    database: str, identity: _DatabaseIdentity, owner: int
+) -> _LinkDirectory:
+    # Beside the database because a link cannot cross filesystems, and TMPDIR is often on another one.
+    parent: Final = pathlib.Path(database).parent
+    _sweep_links_of_the_dead(parent, identity, owner)
+    path: Final = pathlib.Path(tempfile.mkdtemp(prefix=_link_prefix(), dir=parent))
+    fd: Final = os.open(path, _DIRECTORY_FLAGS)
+    try:
+        made: Final = os.fstat(fd)
+        # Whoever can rename in the parent can put another directory under the new name before it opens.
+        if made.st_uid != owner or made.st_mode & 0o077:
+            msg = f"link directory {os.fspath(path)!r} was replaced while opening"
+            raise OSError(msg)
+        link: Final = _LinkDirectory(path, (made.st_dev, made.st_ino), secrets.token_hex(8))
+        try:
+            os.mkdir(link.name, 0o700, dir_fd=fd)
+            os.link(database, link.database, follow_symlinks=False)
+            linked: Final = link.database.stat(follow_symlinks=False)
+        except BaseException:
+            _remove_link_directory(link)
+            raise
+    finally:
+        os.close(fd)
+    if (linked.st_dev, linked.st_ino) != identity:
+        _remove_link_directory(link)
+        msg = f"lock database changed while opening: {database!r}"
+        raise OSError(msg)
+    return link
+
+
+def _sweep_links_of_the_dead(
+    parent: pathlib.Path, identity: _DatabaseIdentity, owner: int
+) -> None:  # pragma: needs posix-hard-link
+    # A process killed while it held a link leaves the directory, and an extra link to the database, behind for good.
+    # Two threads sweeping at once only both try the same removals, which a lock would cost a fork-safety reset for.
+    if identity in _SWEPT_DATABASES:
+        return
+    _SWEPT_DATABASES.add(identity)
+    try:
+        with os.scandir(parent) as entries:
+            names: Final = [
+                entry.name
+                for entry in entries
+                if entry.name.startswith(_LINK_PREFIX) and entry.is_dir(follow_symlinks=False)
+            ]
+    except OSError:
+        return
+    for name in names:
+        # A peer sweeping alongside, or a directory this user cannot remove, must not fail the connect.
+        with suppress(OSError):
+            _remove_dead_links(parent / name, identity, owner)
+
+
+def _remove_dead_links(
+    path: pathlib.Path, identity: _DatabaseIdentity, owner: int
+) -> None:  # pragma: needs posix-hard-link
+    if sys.platform == "win32":  # pragma: win32 cover
+        _remove_dead_links_on_windows(path, identity)
+        return
+    # Any directory can carry a dead holder's name after a rename in the parent, so only hard links to this database
+    # go, and the directory only once that leaves it empty.
+    fd: Final = os.open(path, _DIRECTORY_FLAGS)
+    try:
+        # Only a directory this account made carries a holder of its own; a name another account chose is never
+        # parsed, so no PID is probed on its behalf.
+        if os.fstat(fd).st_uid != owner or not _owner_is_gone(path.name):
+            return
+        with os.scandir(fd) as entries:
+            names: Final = [entry.name for entry in entries]
+        for entry in names:
+            # Releases up to 4.2.0 linked the database right inside the directory.
+            if entry == _LINK_NAME:
+                _unlink_link_to(identity, fd)
+                continue
+            try:
+                nested = os.open(entry, _DIRECTORY_FLAGS, dir_fd=fd)
+            except OSError:
+                continue
+            try:
+                _unlink_link_to(identity, nested)
+            finally:
+                os.close(nested)
+            with suppress(OSError):
+                os.rmdir(entry, dir_fd=fd)
+    finally:
+        os.close(fd)
+    with suppress(OSError):
+        path.rmdir()
+
+
+def _unlink_link_to(identity: _DatabaseIdentity, dir_fd: int) -> None:  # pragma: needs posix-hard-link
+    try:
+        linked: Final = os.stat(_LINK_NAME, dir_fd=dir_fd, follow_symlinks=False)
+    except OSError:
+        return
+    if (linked.st_dev, linked.st_ino) == identity:
+        os.unlink(_LINK_NAME, dir_fd=dir_fd)
+
+
+def _owner_is_gone(name: str) -> bool:  # pragma: needs posix-hard-link
+    match name.removeprefix(_LINK_PREFIX).split("-"):
+        case [pid, start, digest, _] if (
+            pid.isascii() and pid.isdigit() and (not start or (start.isascii() and start.isdigit()))
+        ):
+            if not 1 <= (owner_pid := int(pid)) <= 2**31 - 1:
+                return False
+            host: Final = host_name()
+            return digest == _host_digest(host) and owner_is_stale(owner_pid, host, int(start) if start else None)
+        case _:
+            return False
+
+
+def _link_prefix() -> str:  # pragma: needs posix-hard-link
+    # The owner rides in the name, which mkdtemp creates in one step, so no directory ever exists without it.
+    start: Final = process_start_token(pid := os.getpid())
+    return f"{_LINK_PREFIX}{pid}-{'' if start is None else start}-{_host_digest(host_name())}-"
+
+
+def _host_digest(host: str) -> str:  # pragma: needs posix-hard-link
+    # SHA-256 as host_name does: some runtimes, GraalPy's among them, have no BLAKE2 with a custom digest size.
+    return hashlib.sha256(host.encode()).hexdigest()[:16]
+
+
+def _remove_link_directory(link: _LinkDirectory) -> None:  # pragma: needs posix-hard-link
+    if sys.platform == "win32":  # pragma: win32 cover
+        _remove_link_directory_on_windows(link)
+        return
+    # A rename in the parent may have put any directory under this name, so entries go through a descriptor checked
+    # to be the directory made, and the name goes only through rmdir, which refuses a non-empty directory.
+    try:
+        fd: Final = os.open(link.path, _DIRECTORY_FLAGS)
+    except OSError:
+        return
+    try:
+        opened: Final = os.fstat(fd)
+        if (opened.st_dev, opened.st_ino) != link.identity:
+            return
+        for suffix in ("", "-journal", "-wal", "-shm"):
+            with suppress(FileNotFoundError):
+                os.unlink(f"{link.name}/{_LINK_NAME}{suffix}", dir_fd=fd)
+        with suppress(FileNotFoundError):
+            os.rmdir(link.name, dir_fd=fd)
+    finally:
+        os.close(fd)
+    # The link is gone, so a failure here leaves one stray empty directory and is not worth failing a release for.
+    with suppress(OSError):
+        link.path.rmdir()
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+
+    def _link_beside_on_windows(database: str, identity: _DatabaseIdentity) -> _LinkDirectory:
+        parent: Final = pathlib.Path(database).parent
+        # No uid exists here: a directory is a dead holder's only if its ACL admits nobody but the trusted accounts.
+        _sweep_links_of_the_dead(parent, identity, 0)
+        path: Final = parent / f"{_link_prefix()}{secrets.token_hex(8)}"
+        _make_private_directory(os.fspath(path))
+        link: _LinkDirectory | None = None
+        try:
+            # The handle keeps a rename in the parent from swapping the directory while the link is made inside it.
+            with _pinned(os.fspath(path)) as directory_identity:
+                link = _LinkDirectory(path, directory_identity, secrets.token_hex(8))
+                _fill_link_directory(link, database, identity)
+        except BaseException:
+            if link is not None:  # pragma: no branch  # a pinned directory always gets its link
+                _remove_link_directory(link)
+            raise
+        return link
+
+    def _fill_link_directory(link: _LinkDirectory, database: str, identity: _DatabaseIdentity) -> None:
+        if not _directory_is_private(os.fspath(link.path)):
+            msg = f"link directory {os.fspath(link.path)!r} was replaced while opening"
+            raise OSError(msg)
+        _make_private_directory(os.fspath(link.path / link.name))
+        os.link(database, link.database)
+        # The open database handle pins its path against a rename, so only a file index that is not unique can differ.
+        if _identity_at(os.fspath(link.database)) != identity:  # pragma: no cover
+            msg = f"lock database changed while opening: {database!r}"
+            raise OSError(msg)
+
+    def _remove_dead_links_on_windows(path: pathlib.Path, identity: _DatabaseIdentity) -> None:
+        with _pinned(os.fspath(path)):
+            if not _directory_is_private(os.fspath(path)) or not _owner_is_gone(path.name):
+                return
+            with os.scandir(path) as entries:
+                nested: Final = [pathlib.Path(entry.path) for entry in entries]
+            for directory in nested:
+                _unlink_link_to_on_windows(identity, directory / _LINK_NAME)
+                with suppress(OSError):
+                    directory.rmdir()
+        with suppress(OSError):
+            path.rmdir()
+
+    def _unlink_link_to_on_windows(identity: _DatabaseIdentity, path: pathlib.Path) -> None:
+        with suppress(OSError):
+            if _identity_at(os.fspath(path)) == identity:
+                path.unlink()
+
+    def _remove_link_directory_on_windows(link: _LinkDirectory) -> None:
+        # A removal never fails a release: SQLite or a scanner may still hold a name, and the next sweep retries.
+        with suppress(OSError):
+            with _pinned(os.fspath(link.path)) as directory_identity:
+                if directory_identity != link.identity:
+                    return
+                for suffix in ("", "-journal", "-wal", "-shm"):
+                    with suppress(FileNotFoundError):
+                        pathlib.Path(f"{link.database}{suffix}").unlink()
+                with suppress(FileNotFoundError):
+                    pathlib.Path(link.database.parent).rmdir()
+            link.path.rmdir()
+
+
+def _open_lock_database(database: str, *, oplock_wait: float = 0) -> int:
+    if sys.platform == "win32":  # pragma: win32 cover
+        # The handle refuses a reparse point and omits delete sharing, so the name cannot be swapped while it is open.
+        if (fd := _open_non_reparse_fd(database, 0o600, oplock_wait=oplock_wait)) is None:
+            msg = f"lock database {database!r} is held without sharing or pending deletion"
+            raise PermissionError(msg)
+        return fd
+    fd = os.open(database, _DB_OPEN_FLAGS, 0o600)  # pragma: win32 no cover
+    if not stat.S_ISREG(os.fstat(fd).st_mode):  # pragma: win32 no cover
+        os.close(fd)
+        msg = f"refusing a non-regular lock database: {database!r}"
+        raise OSError(msg)
+    return fd  # pragma: win32 no cover
+
+
+def _raise_if_wal(fd: int, database: str) -> None:
+    # SQLite derives the -wal name from the path it connects through, a descriptor name on POSIX, and WAL never blocks
+    # readers behind a writer, so the lock cannot work on such a database.
+    # pread: an adopted probe is shared, so its file offset is not this connect's to move.
+    header: Final = os.pread(fd, _HEADER_SIZE, 0) if hasattr(os, "pread") else os.read(fd, _HEADER_SIZE)
+    if header.startswith(_SQLITE_MAGIC) and _WAL_FORMAT_VERSION in header[_FORMAT_VERSIONS]:
+        msg = f"refusing a WAL-mode lock database: {database!r}; give ReadWriteLock a file of its own"
+        raise ValueError(msg)
+
+
+@contextmanager
+def _bounded_schema(connection: sqlite3.Connection, database: str) -> Generator[None]:
+    # The first statement loads the file's complete schema, which no timeout bounds, and a lock database has none.
+    # Waiting for a lock runs no virtual machine steps, so a step budget bounds only that load.
+    calls: Final = count()
+    max_calls: Final = 10
+    connection.setlimit(sqlite3.SQLITE_LIMIT_LENGTH, 4096)
+    connection.set_progress_handler(lambda: next(calls) >= max_calls, 1000)
+    try:
+        yield
+    except sqlite3.DatabaseError as error:
+        # An interrupted schema load reports a malformed schema rather than the interrupt.
+        if isinstance(error, sqlite3.DataError) or next(calls) > max_calls:
+            msg = (
+                f"refusing a lock database whose schema is too large to load: {database!r}; "
+                "give ReadWriteLock a file of its own"
+            )
+            raise ValueError(msg) from error
+        raise
+    finally:
+        connection.set_progress_handler(None, 0)
+
+
+@contextmanager
+def _sqlite_transition() -> Generator[None]:
+    _SQLITE_TRANSITION_CONTEXT.depth += 1
+    try:
+        yield
+    finally:
+        _SQLITE_TRANSITION_CONTEXT.depth -= 1
+
+
+def _abort_forked_sqlite_transition() -> None:  # pragma: forked child
+    if _SQLITE_TRANSITION_CONTEXT.depth:
+        os._exit(_UNSAFE_FORK_EXIT_STATUS)  # inherited SQLite handles cannot be used or closed safely
+
+
+def _track_sqlite_use(event: str, _args: Unused) -> None:
+    if event == "sqlite3.connect":
+        _FORKED_DATABASES.note_sqlite_use()
+
+
+def timeout_for_sqlite(timeout: float, *, blocking: bool, already_waited: float) -> int:
+    if blocking is False:
+        return 0
+
+    if timeout == -1:
+        return _MAX_SQLITE_TIMEOUT_MS
+
+    if timeout < 0:
+        msg = "timeout must be a non-negative number or -1"
+        raise ValueError(msg)
+
+    timeout_ms = int((max(timeout - already_waited, 0) if timeout > 0 else timeout) * 1000)
+    if timeout_ms > _MAX_SQLITE_TIMEOUT_MS or timeout_ms < 0:
+        _LOGGER.warning("timeout %s is too large for SQLite, using %s ms instead", timeout, _MAX_SQLITE_TIMEOUT_MS)
+        return _MAX_SQLITE_TIMEOUT_MS
+    return timeout_ms
+
+
+_register_fork_object(_CONNECTION_ESCROW)
+_register_fork_object(_FORKED_DATABASES)
+_register_fork_object(_PROBE_DESCRIPTORS)
+_register_fork_class(ReadWriteLock)
+if _IS_PYPY:
+    sys.addaudithook(_track_sqlite_use)  # pragma: pypy cover
+if hasattr(os, "register_at_fork"):  # pragma: needs fork
+    os.register_at_fork(after_in_child=_abort_forked_sqlite_transition)
+
+__all__ = [
+    "ReadWriteLock",
+    "timeout_for_sqlite",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft.py
new file mode 100644
index 0000000000000000000000000000000000000000..d54fffa70d700a341ed84d6c551c4f59c585da6e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft.py
@@ -0,0 +1,643 @@
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "contextlib",
+    "filelock._identity",
+    "filelock._soft_protocol",
+    "filelock._util",
+    "itertools",
+    "pathlib",
+    "re",
+    "secrets",
+    "typing",
+]
+
+import os
+import re
+import secrets
+import stat
+import sys
+import threading
+import time
+from contextlib import suppress
+from errno import EACCES, EEXIST, EPERM
+from itertools import islice
+from pathlib import Path
+from typing import Final
+
+from filelock._api import BaseFileLock, _raise_grouped_errors
+from filelock._identity import host_name, owner_is_current_process, owner_is_stale, process_start_token
+from filelock._soft_protocol import STRICT_SOFT_SENTINEL_RECORD
+from filelock._util import (
+    break_lock_file,
+    exchange_names,
+    exchange_supported,
+    pin_inode,
+    raise_on_not_writable_file,
+    remove_own_file,
+    write_all,
+)
+
+if sys.platform == "win32":  # pragma: win32 cover
+    from filelock._windows import open_read_without_oplock_wait
+    from filelock._windows import unlink_without_oplock_wait as unlink_path
+else:  # pragma: win32 no cover
+    from filelock._util import unlink_path
+
+MALFORMED_LOCK_AGE_THRESHOLD: Final[float] = 2.0
+_MAX_LOCK_FILE_SIZE: Final[int] = 1024
+_UNLINK_MAX_RETRIES: Final[int] = 10
+_MARKER_WITH_START_TOKEN_LINE_COUNT: Final[int] = 3
+#: Contenders act on the record in the marker, so no other account may write it, whatever the mode or umask.
+_OTHERS_WRITE: Final[int] = stat.S_IWGRP | stat.S_IWOTH
+#: All a SoftFileLock before 3.22 writes, and what a current one shows between creating its marker and writing it.
+_RECORDLESS_MARKER: Final[str] = ""
+_CLAIMS_IN_PROGRESS: Final[set[str]] = set()
+_CLAIMS_LOCK: Final[threading.Lock] = threading.Lock()
+
+
+class SoftFileLock(BaseFileLock):
+    """
+    Cooperative file lock based on a shared existence marker.
+
+    Unlike :class:`UnixFileLock <filelock.UnixFileLock>` and :class:`WindowsFileLock <filelock.WindowsFileLock>`, this
+    lock does not use OS-level locking primitives. Instead, it creates the lock file with ``O_CREAT | O_EXCL`` and
+    treats its existence as the lock indicator. The filesystem must provide coherent exclusive creation and directory
+    updates to each participating process. A crash can leave the marker behind.
+
+    The marker contains the holder's PID and hostname. A contender may remove it when it can no longer find a same-host
+    process with that PID. A configured :attr:`~filelock.BaseFileLock.lifetime` also permits removal based on marker
+    age, including while the holder remains alive. Age-based expiry can overlap protected operations and does not
+    provide strict mutual exclusion.
+
+    """
+
+    #: Existence locks reclaim by unlinking a pathname, so an age-based lease may break one; a native inode lock cannot.
+    _lifetime_supported: bool = True
+
+    #: Age-based expiry preserves historical behavior but does not provide strict mutual exclusion.
+    _lifetime_replacements: tuple[str, str] | None = ("StrictSoftFileLock", "SoftFileLease")
+
+    #: An existence lock unlinks its marker to release, so it cannot promise to keep the pathname.
+    _preserve_lock_file_supported: bool = False
+
+    #: An existence lock keeps protocol state in its marker, so it cannot lend the descriptor to an on_acquired hook.
+    _on_acquired_supported: bool = False
+
+    #: The marker's (mtime, inode, ctime) when this instance last saw it change, and when, on its monotonic clock.
+    _marker_seen: tuple[tuple[float, int, int], float] | None = None
+
+    #: The identity of a marker a Windows release relinquished but has not unlinked yet.
+    _marker_cleanup: tuple[int, int] | None = None
+
+    #: The descriptor of that marker while its close has not run yet, as a list so one C call can take it.
+    _marker_fds: list[int]
+
+    def _acquire(self) -> None:
+        self._finish_marker_cleanup()
+        raise_on_not_writable_file(self._lock_path)
+        # O_CREAT | O_EXCL makes the create fail with EEXIST when the file already exists, so a successful open
+        # means this process now holds the lock.
+        flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | os.O_TRUNC
+        if (o_nofollow := getattr(os, "O_NOFOLLOW", None)) is not None:  # pragma: needs o-nofollow
+            flags |= o_nofollow
+        try:
+            fd = os.open(self._lock_path, flags, self._open_mode() & ~_OTHERS_WRITE)
+        except OSError as exception:
+            if not (
+                exception.errno == EEXIST or (exception.errno == EACCES and sys.platform == "win32")
+            ):  # pragma: win32 no cover
+                raise
+            self._try_break_stale_lock()
+            return
+        # Publish held state only once the record is on disk. On failure, cancellation included, close the descriptor
+        # and unlink the path only while it still names the file we opened: after an expired lease a successor's
+        # marker may sit at the same path. The guard starts at the open, so a signal handler that raises before
+        # _mark_descriptor_owned leaves no marker behind.
+        identity: tuple[int, int] | None = None
+        try:
+            identity = _file_identity(os.fstat(fd))
+            self._mark_descriptor_pending(fd)
+            self._apply_explicit_mode(fd)
+            self._write_lock_info(fd)
+            self._mark_descriptor_owned(fd, identity)
+        except BaseException:
+            self._mark_descriptor_released()
+            try:
+                if sys.platform != "win32":  # pragma: win32 no cover
+                    # Before the close: our open descriptor keeps the inode allocated, so a successor's marker cannot
+                    # carry its number.
+                    with suppress(OSError):
+                        remove_own_file(self._lock_path, fd)
+            finally:
+                try:
+                    os.close(fd)
+                finally:
+                    if sys.platform == "win32":  # pragma: win32 cover
+                        self._unlink_held_marker(identity)
+            raise
+
+    def _apply_explicit_mode(self, fd: int) -> None:
+        # os.open filters the mode through the umask, so an explicit mode lands as given only through fchmod, the way
+        # UnixFileLock applies it. Windows maps the mode to a read-only bit that os.open already set.
+        if self.has_explicit_mode and sys.platform != "win32":  # pragma: win32 no cover
+            with suppress(PermissionError):
+                os.fchmod(fd, self._context.mode & ~_OTHERS_WRITE)
+
+    def _try_break_stale_lock(self) -> None:
+        with suppress(OSError, ValueError), pin_inode(self._lock_path) as pinned:
+            content, marker = _read_lock_file(self._lock_path)
+            if pinned not in {None, marker.st_ino}:  # pragma: win32 no cover  # Windows pins nothing
+                return  # another node replaced the pinned one before the read, and nothing keeps its number from reuse
+            if content == STRICT_SOFT_SENTINEL_RECORD:  # pragma: needs hard-link
+                return
+            # Such a marker is held for as long as its owner runs, so being unchanged proves nobody gone.
+            if content == _RECORDLESS_MARKER:
+                return
+            holder = _parse_lock_holder(content)
+
+            if holder is None:
+                # Unparsable: wrong line count, a non-integer PID or start token, empty, oversized or not UTF-8.
+                # Self-heal only once the file is clearly not a half-written fresh lock (a peer between O_EXCL and
+                # _write_lock_info), so the brief create-then-write window is never mistaken for a stale lock.
+                if self._marker_unchanged_for(marker) >= MALFORMED_LOCK_AGE_THRESHOLD:
+                    self._take_over(marker, _placeholder_breaker(content))
+                return
+
+            if owner_is_stale(*holder):
+                self._take_over(marker, holder[0])
+
+    def _try_break_expired_lock(self) -> None:
+        if (lifetime := self._context.lifetime) is None:
+            return
+        with suppress(OSError), pin_inode(self._lock_path) as pinned:
+            # _read_lock_file takes the lstat, not stat: a symlink swapped in at the path must report its own mtime.
+            content, marker = _read_lock_file(self._lock_path)
+            if pinned not in {None, marker.st_ino} or time.time() - marker.st_mtime < lifetime:
+                return
+            holder = self._recorded_holder(content)
+            self._take_over(marker, None if holder is None else holder[0])
+
+    def _take_over(self, marker: os.stat_result, breaker_pid: int | None) -> None:
+        # Swap the judged marker for a complete marker of ours in one exchange, so the lock path never stands empty.
+        # Once the file swapped out proves to be the one judged, this lock holds the path; the caller's pin keeps that
+        # file's inode number from naming anything else. Only a peer's exchange can move our marker after that, and
+        # the peer puts it back because what it took is not the file it judged. Every failure before the handoff takes
+        # our marker off the path and puts back what the exchange took. Without an exchange, the portable break decides.
+        if exchange_supported():  # pragma: win32 no cover
+            self._take_over_by_exchange(marker, breaker_pid)
+        else:
+            break_lock_file(self._lock_path, marker.st_mtime, marker.st_ino)
+
+    def _take_over_by_exchange(self, marker: os.stat_result, breaker_pid: int | None) -> None:  # pragma: win32 no cover
+        if (current := os.lstat(self._lock_path)).st_mtime != marker.st_mtime or current.st_ino != marker.st_ino:
+            return
+        if breaker_pid is not None and self._restore_stranded_marker(breaker_pid, marker):
+            return
+        aside: Final = f"{self._lock_path}.break.{os.getpid()}.{secrets.token_hex(16)}"
+        flags: Final = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0)
+        fd: Final = os.open(aside, flags, self._open_mode() & ~_OTHERS_WRITE)
+        self._mark_descriptor_pending(fd)
+        exchanged = held = False
+        try:
+            identity: Final = _file_identity(os.fstat(fd))
+            self._apply_explicit_mode(fd)
+            self._write_lock_info(fd)
+            if not exchange_names(aside, self._lock_path):
+                return  # NFS, SMB and the like refuse it; renaming the marker aside would empty the path
+            exchanged = True
+            if (taken := os.lstat(aside)).st_mtime != marker.st_mtime or taken.st_ino != marker.st_ino:
+                return  # a peer recreated the marker, which the cleanup below swaps back
+            Path(aside).unlink()
+            exchanged = False
+            self._mark_descriptor_owned(fd, identity)
+            held = True
+        finally:
+            if not held:
+                self._abandon_take_over(fd, aside, put_back=exchanged)
+
+    def _restore_stranded_marker(self, breaker_pid: int, marker: os.stat_result) -> bool:  # pragma: win32 no cover
+        # A breaker killed between its exchange and the put-back leaves its own marker at the path and the live
+        # holder's marker under its break name. A recoverer first renames that record to a name of its own. Only one
+        # contender wins the rename, so two of them never exchange the same record and reverse each other. A record
+        # a dead recoverer holds is claimable again. A claim of this process that no thread is working on was
+        # abandoned by a failed put-back, and the next poll takes it up again. Where the marker cannot be put back
+        # the lock counts as held, as it does wherever no exchange is possible.
+        if (candidates := self._stranded_candidates(breaker_pid)) is None:
+            return True
+        return any(self._recover_claimed(path, breaker_pid, marker, adopt=abandoned) for path, abandoned in candidates)
+
+    def _stranded_candidates(self, breaker_pid: int) -> list[tuple[str, bool]] | None:  # pragma: win32 no cover
+        directory, name = os.path.split(self._lock_path)
+        stranded: Final = re.compile(rf"{re.escape(name)}\.break\.{breaker_pid}\.[0-9a-f]{{32}}")
+        claimed: Final = re.compile(rf"{re.escape(name)}\.restore\.(\d+)\.[0-9a-f]{{32}}")
+        candidates: list[tuple[str, bool]] = []
+        with os.scandir(directory or os.curdir) as entries:
+            for entry in entries:
+                if not entry.is_file(follow_symlinks=False):
+                    continue
+                path = str(Path(directory) / entry.name)
+                if stranded.fullmatch(entry.name):
+                    candidates.append((path, False))
+                elif found := claimed.fullmatch(entry.name):
+                    ours = int(found[1]) == os.getpid()
+                    if not (ours or owner_is_stale(int(found[1]), host_name(), None)):
+                        return None
+                    candidates.append((path, ours))
+        return sorted(candidates)
+
+    def _recover_claimed(
+        self, path: str, breaker_pid: int, marker: os.stat_result, *, adopt: bool
+    ) -> bool:  # pragma: win32 no cover
+        # One try/finally owns the registration from the first step to the last, so no interruption can leave it set.
+        # Registered before the rename publishes the name, so a thread that scans meanwhile sees a claim in progress.
+        own: Final = path if adopt else f"{self._lock_path}.restore.{os.getpid()}.{secrets.token_hex(16)}"
+        if not _begin_claim(own):
+            return True
+        try:
+            if not adopt:
+                try:
+                    Path(path).rename(own)
+                except OSError:  # a peer that won the rename now holds the record, so the lock counts as held
+                    return True
+            return self._restore_claimed(own, breaker_pid, marker)
+        finally:
+            _end_claim(own)
+
+    def _restore_claimed(self, own: str, breaker_pid: int, marker: os.stat_result) -> bool:  # pragma: win32 no cover
+        try:
+            content, _ = _read_lock_file(own)
+        except OSError:
+            self._return_claim(own, breaker_pid)
+            return True
+        if not self._marker_is_live(content, breaker_pid):
+            with suppress(OSError):
+                Path(own).unlink()
+            return False
+        # The inode of the marker judged dead must still be at the path, or a peer has acted since.
+        with suppress(OSError):
+            current = os.lstat(self._lock_path)
+            if (current.st_ino, current.st_mtime) == (marker.st_ino, marker.st_mtime) and exchange_names(
+                own, self._lock_path
+            ):
+                if os.lstat(own).st_ino == marker.st_ino:
+                    Path(own).unlink()
+                    return True
+                # A peer replaced the path after the check, so the exchange took its marker: swap it straight back.
+                exchange_names(own, self._lock_path)
+        self._return_claim(own, breaker_pid)
+        return True
+
+    def _return_claim(self, own: str, breaker_pid: int) -> None:  # pragma: win32 no cover
+        # A refused rename leaves the claim under this process's PID, and the next poll retries it.
+        with suppress(OSError):
+            Path(own).rename(f"{self._lock_path}.break.{breaker_pid}.{secrets.token_hex(16)}")
+
+    @classmethod
+    def _marker_is_live(cls, content: str | None, breaker_pid: int) -> bool:  # pragma: win32 no cover
+        if content == STRICT_SOFT_SENTINEL_RECORD:  # pragma: needs hard-link
+            return True
+        if content == _RECORDLESS_MARKER:
+            # An empty marker is a pre-3.22 holder for as long as it exists, as the stale check treats it.
+            return True
+        # The breaker's own marker names its PID on this host; the same number on another host is a holder.
+        return (
+            (holder := _parse_lock_holder(content)) is not None
+            and (holder[0] != breaker_pid or holder[1] != host_name())
+            and not owner_is_stale(*holder)
+        )
+
+    def _abandon_take_over(self, fd: int, aside: str, *, put_back: bool) -> None:  # pragma: win32 no cover
+        self._mark_descriptor_released()
+        try:
+            if put_back:
+                exchange_names(aside, self._lock_path)
+        finally:
+            try:
+                # Whichever name still holds our marker loses it: the descriptor keeps its inode number ours.
+                own: Final = os.fstat(fd)
+                for name in (self._lock_path, aside):
+                    with suppress(FileNotFoundError):
+                        if os.path.samestat(os.lstat(name), own):
+                            Path(name).unlink()
+            finally:
+                os.close(fd)
+
+    def _marker_unchanged_for(self, marker: os.stat_result) -> float:
+        # The mtime is the writer's or file server's clock, so against time.time() a contender whose clock runs ahead
+        # would expire a fresh marker. Only watch it for change, timed on this process's monotonic clock. The owner of a
+        # file sets its mtime, and ext4 reuses a freed inode number, so a new marker can repeat both. The change time
+        # cannot be set and moves with every create, which keeps a new marker from inheriting an old one's age.
+        now: Final = time.monotonic()
+        key: Final = marker.st_mtime, marker.st_ino, marker.st_ctime_ns
+        if (seen := self._marker_seen) is None or seen[0] != key:
+            self._marker_seen = key, now
+            return 0.0
+        return now - seen[1]
+
+    def _unprobeable_holder(self) -> str | None:
+        # This host cannot prove such a holder dead, so whoever decides whether it is gone needs its name.
+        with suppress(OSError, ValueError):
+            if (content := _read_lock_file(self._lock_path)[0]) == _RECORDLESS_MARKER:
+                return "an owner that recorded no PID (a filelock release before 3.22, or one still writing its record)"
+            if (holder := self._recorded_holder(content)) and holder[1] != host_name():
+                return f"pid {holder[0]} on {holder[1]}"
+        return None
+
+    @classmethod
+    def _recorded_holder(cls, content: str | None) -> tuple[int, str] | None:
+        return None if (holder := _parse_lock_holder(content)) is None else holder[:2]
+
+    @staticmethod
+    def _write_lock_info(fd: int) -> None:
+        # No suppression: a write failure must reach the acquisition rollback so it never publishes a half-written
+        # marker as held state. The optional third line is this process's start token, absent when the platform
+        # exposes no proven start time, in which case a reader falls back to PID-only liveness.
+        info = f"{os.getpid()}\n{host_name()}\n"
+        if (token := process_start_token(os.getpid())) is not None:
+            info += f"{token}\n"
+        write_all(fd, info.encode())
+
+    @property
+    def pid(self) -> int | None:
+        """
+        The PID of the process holding this lock, read from the lock file.
+
+        :returns: the PID as an integer, or ``None`` if the lock file does not exist or cannot be parsed
+
+        """
+        with suppress(OSError, ValueError):
+            holder = _parse_lock_holder(_read_lock_file(self._lock_path)[0])
+            if holder is not None:
+                return holder[0]
+        return None
+
+    @property
+    def is_lock_held_by_us(self) -> bool:
+        """
+        Whether this lock is held by the current process.
+
+        :returns: ``True`` if the lock file exists and names the current process's PID, hostname and, when recorded,
+            start token
+
+        """
+        with suppress(OSError, ValueError):
+            if (holder := _parse_lock_holder(_read_lock_file(self._lock_path)[0])) is not None:
+                return owner_is_current_process(*holder)
+        return False
+
+    def break_lock(self) -> None:
+        """Forcibly break the lock by removing the lock file, regardless of who holds it."""
+        with suppress(OSError):
+            Path(self._lock_path).unlink()
+
+    def _release_current(self, *, force: bool) -> None:
+        try:
+            super()._release_current(force=force)
+        finally:
+            # A release a handler cut short after the descriptor closed still owes the unlink on Windows.
+            self._finish_marker_cleanup()
+
+    def _release(self) -> None:
+        fd = self._context.lock_file_fd
+        assert fd is not None  # ruff:ignore[assert]  # _release runs only while held, so the descriptor is set
+        # Capture the held file's identity before closing so cleanup can refuse to unlink a successor's marker. A
+        # supported lifetime lease lets a peer break our expired marker and create its own at this path before we
+        # release; unlinking by path alone would then delete the successor's lock.
+        identity: tuple[int, int] | None = None
+        with suppress(OSError):
+            identity = _file_identity(os.fstat(fd))
+        if sys.platform == "win32":  # pragma: win32 cover
+            self._release_then_unlink(fd, identity)
+        else:  # pragma: win32 no cover
+            # Our open descriptor keeps the inode allocated, so its number cannot name a successor's marker yet, and an
+            # interrupt before the unlink lands leaves the lock held for the retried release to finish.
+            unlinked: Final = self._unlink_open_marker(fd, identity)
+            # A failed close may already have released and recycled the descriptor number. Relinquish it before the
+            # one close attempt so no later release can close an unrelated descriptor that reused the same integer.
+            self._mark_descriptor_released()
+            try:
+                self._close_released_fd(fd, default_suppresses=False)
+            finally:
+                # A share that refuses to delete an open file gets the unlink after the close; the marker still exists
+                # until then, so its inode cannot be reused either.
+                if not unlinked:
+                    self._unlink_held_marker(identity)
+
+    def _release_then_unlink(self, fd: int, identity: tuple[int, int] | None) -> None:  # pragma: win32 cover
+        # Windows cannot unlink an open file, so the unlink outlives the hold until it lands, here or on a later acquire
+        # or release. Only the gate's holder touches the pending record, so two threads never overwrite each other's.
+        with self._transition_lock:
+            self._marker_fds = [fd]
+            self._marker_cleanup = identity
+            self._mark_descriptor_released()
+            try:
+                self._close_marker_fd()
+            # Marker cleanup must also run for control-flow exceptions, and both failures must remain observable.
+            except BaseException as close_error:
+                try:
+                    self._finish_marker_cleanup()
+                except BaseException as cleanup_error:  # ruff:ignore[blind-except]  # keep control-flow failures
+                    _raise_grouped_errors(
+                        "lock descriptor close and marker cleanup both failed",
+                        close_error,
+                        cleanup_error,
+                    )
+                raise
+            self._finish_marker_cleanup()
+
+    def _marker_names(self) -> tuple[str, ...]:
+        # After a rename of the lock's directory only the caller's spelling, resolved through the working directory,
+        # still reaches the marker this hold opened.
+        return tuple(dict.fromkeys((self._lock_path, self.lock_file)))
+
+    def _unlink_open_marker(self, fd: int, identity: tuple[int, int] | None) -> bool:  # pragma: win32 no cover
+        if identity is None:
+            return True
+        replaced = False
+        for name in self._marker_names():
+            try:
+                if _file_identity(os.lstat(name)) == identity:
+                    Path(name).unlink()
+                    return True
+                replaced = True
+            except FileNotFoundError:
+                continue
+            except OSError:
+                return False
+        if replaced:
+            try:
+                _leave_released_record(fd)
+            except OSError:
+                return False
+        return True
+
+    def _finish_marker_cleanup(self) -> None:
+        # Never waits: whoever holds the gate is acquiring or releasing this lock and finishes the cleanup itself.
+        if self._marker_cleanup is not None and self._transition_lock.acquire(blocking=False):  # pragma: win32 cover
+            try:
+                # A close error here belongs to the release an interrupt cut short, not to this caller.
+                with suppress(OSError):
+                    self._close_marker_fd()
+                if (identity := self._marker_cleanup) is not None:  # pragma: no branch  # the gate's holder clears it
+                    self._windows_unlink_if_ours(identity)
+            finally:
+                self._transition_lock.release()
+
+    def _close_marker_fd(self) -> None:  # pragma: win32 cover
+        # Popping and closing is one chain of C calls that no signal handler can split, so a retried release closes the
+        # descriptor at most once; a second close could hit an unrelated file that reused the number.
+        try:
+            list(map(os.close, islice(iter(vars(self).setdefault("_marker_fds", []).pop, None), 1)))
+        except IndexError:
+            return
+        except OSError:
+            if not self._suppresses_close_error(default_suppresses=False):
+                raise
+
+    def _unlink_held_marker(self, identity: tuple[int, int] | None) -> None:
+        if sys.platform == "win32":  # pragma: win32 cover
+            if identity is not None:
+                self._windows_unlink_if_ours(identity)
+        else:  # pragma: win32 no cover
+            for name in self._marker_names():
+                with suppress(OSError):
+                    if _file_identity(os.lstat(name)) == identity:
+                        Path(name).unlink()
+                        return
+
+    def _windows_unlink_if_ours(self, identity: tuple[int, int]) -> None:  # pragma: win32 cover
+        retry_delay = 0.001
+        for attempt in range(_UNLINK_MAX_RETRIES):
+            # Windows doesn't immediately release file handles after close, causing EACCES/EPERM on unlink. Recheck
+            # identity each attempt: a failed unlink leaves a window for a successor to replace the marker at this path.
+            try:
+                for name in self._marker_names():
+                    with suppress(FileNotFoundError):
+                        if _file_identity(os.lstat(name)) == identity:
+                            # Forgotten before the unlink: Windows does not promise unique file IDs, so no retry may
+                            # reach a successor that reused ours.
+                            self._marker_cleanup = None
+                            unlink_path(name)
+                            break
+            except OSError as exc:
+                if exc.errno in {EACCES, EPERM}:
+                    # The file is still ours, so the next acquire or release tries again if these attempts run out.
+                    self._marker_cleanup = identity
+                    if attempt < _UNLINK_MAX_RETRIES - 1:
+                        time.sleep(retry_delay)
+                        retry_delay *= 2
+                    continue
+            self._marker_cleanup = None
+            return
+
+
+def _file_identity(st: os.stat_result) -> tuple[int, int]:
+    # (st_dev, st_ino) names the concrete inode behind a path, so a marker recreated at the same pathname after an
+    # expired lease reads as a different file. CPython populates both on Windows from the volume serial and file index.
+    return st.st_dev, st.st_ino
+
+
+def _begin_claim(name: str | Path) -> bool:  # pragma: win32 no cover
+    # Keyed by the file name alone: its random token identifies the claim, and the spelling of the directory varies.
+    with _CLAIMS_LOCK:
+        if (key := Path(name).name) in _CLAIMS_IN_PROGRESS:
+            return False
+        _CLAIMS_IN_PROGRESS.add(key)
+        return True
+
+
+def _end_claim(name: str | Path) -> None:  # pragma: win32 no cover
+    with _CLAIMS_LOCK:
+        _CLAIMS_IN_PROGRESS.discard(Path(name).name)
+
+
+def _placeholder_breaker(content: str | None) -> int | None:  # pragma: win32 no cover
+    # The placeholder a break leaves at the path while it works names the breaker that may have died there.
+    if content is None or not content.startswith(placeholder := "filelock/break\n") or not content.endswith("\n"):
+        return None
+    with suppress(ValueError):
+        return parse_decimal(content.removeprefix(placeholder)[:-1])
+    return None
+
+
+def _leave_released_record(fd: int) -> None:
+    # A peer's exchange holds our marker under its break name and will put it back. Overwriting the record lets
+    # contenders age it out instead of waiting on this live PID. The write comes before the truncate so the file is
+    # never empty.
+    if sys.platform != "win32":  # pragma: win32 no cover
+        os.pwrite(fd, released := b"filelock/released\n", 0)
+        os.ftruncate(fd, len(released))
+
+
+def _read_lock_file(path: str) -> tuple[str | None, os.stat_result]:
+    # A legitimate lock file is always a regular file. Classify the path with lstat first, so any other node (symlink,
+    # FIFO, socket, device) is reported as a malformed lock the caller can evict, without an os.open that would follow
+    # a symlink, stall on a FIFO, or fail on a socket and leave acquisition wedged. The stat result still flows back
+    # for the identity-checked stale break. lstat, not stat, so a hostile symlink is never followed onto its target.
+    st = os.lstat(path)
+    if not stat.S_ISREG(st.st_mode):  # pragma: needs fifo
+        return None, st
+    # Re-check on the opened handle: O_NOFOLLOW refuses a symlink swapped in after the lstat, O_NONBLOCK stops a FIFO
+    # swapped in from stalling the open, and the fstat catches any other non-regular replacement race before we read.
+    # The capped read stops a huge regular file (e.g. one filled from /dev/zero) from exhausting memory.
+    if sys.platform == "win32":  # pragma: win32 cover
+        # os.open would wait for an oplock holder to answer its break, past the caller's deadline.
+        fd = open_read_without_oplock_wait(path)
+    else:  # pragma: win32 no cover
+        fd = os.open(path, os.O_RDONLY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0))
+    try:
+        st = os.fstat(fd)
+        if not stat.S_ISREG(st.st_mode):  # pragma: no cover  # only a non-regular node swapped in after the lstat
+            return None, st
+        data = os.read(fd, _MAX_LOCK_FILE_SIZE + 1)
+    finally:
+        os.close(fd)
+    if len(data) <= _MAX_LOCK_FILE_SIZE:
+        with suppress(UnicodeDecodeError):
+            return data.decode("utf-8"), st
+    return None, st
+
+
+def _parse_lock_holder(content: str | None) -> tuple[int, str, int | None] | None:
+    # A well-formed lock file is "<pid>\n<hostname>\n" with an optional "<start_token>\n" third line naming the
+    # holder's process start instant (a filelock 3.29 marker wrote this only on Windows; every platform writes it now).
+    # Anything else (wrong line count, a non-integer PID or start token, empty or unreadable content) is unparsable;
+    # returning None lets the caller treat it as a malformed lock to self-heal rather than a holder.
+    # Every writer since 3.22 ends each line with "\n", so a record without one was cut by a crash or read mid-write. As
+    # a holder it would name a foreign host no one reclaims, or a start token that lets a contender break a live lock.
+    if not content or not content.endswith("\n") or len(lines := content.strip().splitlines()) not in {2, 3}:
+        return None
+    try:
+        pid = parse_decimal(lines[0])
+        start_token = parse_decimal(lines[2]) if len(lines) == _MARKER_WITH_START_TOKEN_LINE_COUNT else None
+    except ValueError:
+        return None
+    # A pid outside the valid range is a malformed lock, not a holder. Without this, a non-positive pid
+    # reaches os.kill() where 0 / -1 mean "the caller's own process group / every process" so a dead
+    # holder reads as alive and the lock is never reclaimed, while an oversized pid raises OverflowError
+    # (not OSError/ValueError) out of the self-heal path. _parse_marker_bytes already enforces this range.
+    if not 1 <= pid <= 2**31 - 1:
+        return None
+    return pid, lines[1], start_token
+
+
+def parse_decimal(text: str) -> int:
+    """
+    Read a PID or start token as a writer formats it: ASCII digits only.
+
+    :raises ValueError: for anything else ``int()`` would accept, such as ``1_000``, surrounding whitespace, a sign or
+        non-ASCII digits; no filelock writes those
+
+    """
+    if not (text.isascii() and text.isdigit()):
+        msg = f"not a decimal integer: {text!r}"
+        raise ValueError(msg)
+    return int(text)
+
+
+__all__ = [
+    "MALFORMED_LOCK_AGE_THRESHOLD",
+    "SoftFileLock",
+    "parse_decimal",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_protocol.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_protocol.py
new file mode 100644
index 0000000000000000000000000000000000000000..43f048a6d49b4a35449f36aa10094a309c3f43bf
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_protocol.py
@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["typing"]
+
+from typing import Final
+
+STRICT_SOFT_SENTINEL_RECORD: Final[str] = "1\nfilelock-strict-v1\x00\n0\n"
+
+__all__ = [
+    "STRICT_SOFT_SENTINEL_RECORD",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..9401ecc9ba9b637ab8ea8131273fd22fee474dbd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__init__.py
@@ -0,0 +1,14 @@
+"""Cross-process and cross-host reader/writer lock over a generation log of immutable snapshots."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["filelock._soft_rw._async"]
+
+from filelock._soft_rw._async import AsyncAcquireSoftReadWriteReturnProxy, AsyncSoftReadWriteLock
+from filelock._soft_rw._sync import SoftReadWriteLock
+
+__all__ = [
+    "AsyncAcquireSoftReadWriteReturnProxy",
+    "AsyncSoftReadWriteLock",
+    "SoftReadWriteLock",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f228c8fc7edc334cd99a8c4c7924e0188f997b9
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_async.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_async.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55b40fbabf582ec7c4e4991a735dc53506614459
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_async.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_protocol.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_protocol.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d3f66a7f94a0aa58ec2bad8c70b9445b1ace8047
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_protocol.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_storage.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_storage.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bfbe11eb9f7d6fc0d4681feb2941effb6e3d92dc
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_storage.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_sync.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_sync.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c4b78b20c6b700e4770ce712dd2b62c1565e1743
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/__pycache__/_sync.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_async.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_async.py
new file mode 100644
index 0000000000000000000000000000000000000000..f751d6b95b73f910dd6e3ad12b9729bca820c063
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_async.py
@@ -0,0 +1,373 @@
+"""Async wrapper around :class:`SoftReadWriteLock` for use with ``asyncio``."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["asyncio", "filelock._async", "filelock._error", "functools", "threading"]
+
+import asyncio
+import functools
+import os
+import threading
+from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING, Final, Literal, ParamSpec, TypeVar
+
+from filelock._async import (
+    _TASKS_THREAD_ID,
+    _BackendOutcome,
+    _capture_call,
+    _drain_future,
+    _future_result,
+    _raise_cancelled_error,
+    _task_owners_for,
+    _wait_until_done,
+)
+from filelock._error import Timeout
+from filelock._soft_rw._sync import SoftReadWriteLock, _lost_hold_error
+
+if TYPE_CHECKING:
+    from collections.abc import AsyncGenerator, Callable
+    from concurrent import futures
+    from types import TracebackType
+
+    from filelock._api import AcquireReturnProxy
+    from filelock._lease import LeaseCompromise
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+class AsyncSoftReadWriteLock:
+    """
+    Async wrapper around :class:`SoftReadWriteLock` for ``asyncio`` applications.
+
+    The sync class's blocking filesystem operations run on a thread pool via ``loop.run_in_executor()``. Each
+    ``asyncio`` task owns its own hold. Tasks share a read lock, and a task asking for the write lock waits until the
+    other holders release, with waiting writers ahead of new readers. Upgrading or downgrading a held lock raises
+    :class:`RuntimeError`. The underlying :class:`SoftReadWriteLock` handles forks, the heartbeat, and stale eviction.
+    Singleton wrappers share one sync lock and its task holds, and closing one ends only the holds taken through it.
+
+    :param lock_file: path to the lock file; the protocol directory lives next to it as ``<lock_file>.rw``
+    :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately on contention
+    :param is_singleton: if ``True``, reuse existing :class:`SoftReadWriteLock` instances per resolved path
+    :param heartbeat_interval: seconds between heartbeat refreshes; default 30 s
+    :param stale_threshold: seconds a holder record may stay unchanged before a contender evicts it; defaults to
+        ``3 * heartbeat_interval``
+    :param poll_interval: seconds between acquire retries under contention; default 0.25 s
+    :param on_compromise: called from the heartbeat thread with a :class:`~filelock.LeaseCompromise` when the hold is
+        lost
+    :param loop: event loop for ``run_in_executor``; ``None`` uses the running loop
+    :param executor: executor for ``run_in_executor``; ``None`` uses the default executor
+
+    .. versionadded:: 3.27.0
+
+    """
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+        heartbeat_interval: float = 30.0,
+        stale_threshold: float | None = None,
+        poll_interval: float = 0.25,
+        on_compromise: Callable[[LeaseCompromise], None] | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        executor: futures.Executor | None = None,
+    ) -> None:
+        self._creator_pid = os.getpid()
+        self._closed = False
+        self._owns_backend = not is_singleton
+        #: Marks the task holds taken through this wrapper, which its close() ends.
+        self._via: Final = object()
+        self._lock = SoftReadWriteLock(
+            lock_file,
+            timeout,
+            blocking=blocking,
+            is_singleton=is_singleton,
+            heartbeat_interval=heartbeat_interval,
+            stale_threshold=stale_threshold,
+            poll_interval=poll_interval,
+            on_compromise=on_compromise,
+        )
+        self._owners = _task_owners_for(self._lock)
+        self._loop = loop
+        self._executor = executor
+
+    @property
+    def lock_file(self) -> str:
+        """The path to the lock file passed to the constructor."""
+        return self._lock.lock_file
+
+    @property
+    def timeout(self) -> float:
+        """The default timeout applied when ``acquire_read`` / ``acquire_write`` is called without one."""
+        return self._lock.timeout
+
+    @property
+    def blocking(self) -> bool:
+        """Whether ``acquire_*`` defaults to blocking; ``False`` makes contention raise immediately."""
+        return self._lock.blocking
+
+    @property
+    def generation(self) -> int | None:
+        """The generation the current hold was granted at, a fencing token; ``None`` when no lock is held."""
+        return self._lock.generation
+
+    @property
+    def compromise(self) -> LeaseCompromise | None:
+        """How the current hold was lost, or ``None`` while it stands; acquiring raises until the hold is released."""
+        return self._lock.compromise
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop | None:
+        """The event loop used for ``run_in_executor``, or ``None`` for the running loop."""
+        return self._loop
+
+    @property
+    def executor(self) -> futures.Executor | None:
+        """The executor used for ``run_in_executor``, or ``None`` for the default executor."""
+        return self._executor
+
+    @asynccontextmanager
+    async def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases a shared read lock.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :raises RuntimeError: if the calling task already holds the write lock
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        await self.acquire_read(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            await self.release()
+
+    @asynccontextmanager
+    async def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> AsyncGenerator[None]:
+        """
+        Async context manager that acquires and releases an exclusive write lock.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :raises RuntimeError: if the calling task already holds the read lock
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        await self.acquire_write(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            await self.release()
+
+    async def acquire_read(
+        self, timeout: float | None = None, *, blocking: bool | None = None
+    ) -> AsyncAcquireSoftReadWriteReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        See :meth:`SoftReadWriteLock.acquire_read` for reentrancy / upgrade / fork semantics. The blocking work runs
+        inside ``run_in_executor`` so other coroutines on the same loop keep progressing while this call waits.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :returns: a proxy usable as an async context manager to release the lock
+
+        :raises RuntimeError: if the calling task already holds the write lock, if this instance was invalidated by
+            :func:`os.fork`, or if :meth:`close` was called
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self._raise_if_unusable()
+        await self._acquire("read", timeout, blocking=blocking)
+        return AsyncAcquireSoftReadWriteReturnProxy(lock=self)
+
+    async def acquire_write(
+        self, timeout: float | None = None, *, blocking: bool | None = None
+    ) -> AsyncAcquireSoftReadWriteReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        See :meth:`SoftReadWriteLock.acquire_write` for the writer-preferring semantics. The blocking work runs inside
+        ``run_in_executor``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :returns: a proxy usable as an async context manager to release the lock
+
+        :raises RuntimeError: if the calling task already holds the read lock, if this instance was invalidated by
+            :func:`os.fork`, or if :meth:`close` was called
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self._raise_if_unusable()
+        await self._acquire("write", timeout, blocking=blocking)
+        return AsyncAcquireSoftReadWriteReturnProxy(lock=self)
+
+    async def _acquire(self, mode: Literal["read", "write"], timeout: float | None, *, blocking: bool | None) -> None:
+        blocking = self._lock.blocking if blocking is None else blocking
+
+        async def enter(remaining: float) -> None:
+            # A close() may have landed while this task waited for the table.
+            self._raise_if_unusable()
+            await self._run_acquire(
+                functools.partial(
+                    self._lock._acquire_level_of,  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+                    _TASKS_THREAD_ID,
+                    mode,
+                    remaining,
+                    blocking=blocking,
+                )
+            )
+
+        def joinable() -> bool:
+            self._raise_if_unusable()
+            if (compromise := self._lock.compromise) is not None:
+                raise _lost_hold_error(self.lock_file, mode, compromise)
+            return self._backend_holds()
+
+        await self._owners.acquire(
+            mode,
+            timeout=self._lock.timeout if timeout is None else timeout,
+            blocking=blocking,
+            lock_file=self.lock_file,
+            via=self._via,
+            enter=enter,
+            joinable=joinable,
+        )
+
+    async def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the calling task's hold.
+
+        The wrapper releases the lock once no task holds it.
+
+        :param force: if ``True``, end every level the calling task took through this wrapper. Levels taken through
+            other wrappers on the same path stay. A wrapper that holds no level for the task releases nothing.
+
+        :raises RuntimeError: if the calling task holds no level through this wrapper and *force* is ``False``
+
+        """
+        if self._creator_pid == os.getpid():
+            await self._owners.release(
+                force=force,
+                lock_file=self.lock_file,
+                via=self._via,
+                leave=functools.partial(self._submit, self._leave_backend),
+                still_held=self._backend_holds,
+            )
+
+    async def close(self) -> None:
+        """
+        End the holds of the tasks that acquired through this instance and release the lock once no task holds it.
+
+        Idempotent. After calling this method the instance can no longer acquire locks. With ``is_singleton=False`` it
+        also closes the underlying :class:`SoftReadWriteLock`. A singleton wrapper leaves the shared one open, so tasks
+        that acquired through another wrapper and synchronous users of the same path keep their holds. The next acquire
+        notices a synchronous ``close()`` or forced release of that shared lock. One that lands in the few bytecodes
+        between that check and the admission still admits the task into the ended hold.
+
+        """
+        if self._creator_pid != os.getpid() or self._closed:
+            return
+        # Refuse acquires from here on, so none is admitted into a hold the backend is letting go of.
+        self._closed = True
+        try:
+            await self._owners.retire(
+                None if self._owns_backend else self._via,
+                leave=functools.partial(self._submit, self._lock.close if self._owns_backend else self._leave_backend),
+                still_held=self._backend_holds,
+            )
+        except BaseException as error:
+            # Only a failed backend call can leave the level held, and then a retried close() has to find it.
+            if not isinstance(error, asyncio.CancelledError) and self._backend_holds():
+                self._closed = False
+            raise
+
+    def _raise_if_unusable(self) -> None:
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            msg = f"AsyncSoftReadWriteLock on {self.lock_file} was inherited across fork; construct a new instance"
+            raise RuntimeError(msg)
+        if self._closed:
+            msg = f"AsyncSoftReadWriteLock on {self.lock_file} has been closed"
+            raise RuntimeError(msg)
+
+    def _backend_holds(self) -> bool:
+        # A sync close() or forced release on a shared singleton ends the tasks' level without the table taking part.
+        return self._lock._holds_level_of(_TASKS_THREAD_ID)  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+
+    def _leave_backend(self) -> None:
+        # Only the tasks' level: a sync user of the same singleton keeps its own.
+        self._lock._release_level_of(_TASKS_THREAD_ID)  # ruff:ignore[private-member-access]  # the wrapper owns this backend hold
+
+    async def _run_acquire(self, acquire: Callable[..., AcquireReturnProxy]) -> None:
+        # run_in_executor cannot recall work the pool already started. A sync acquire that won the lock before it saw
+        # the cancellation has published its claim and started the heartbeat, which keeps the record fresh so no peer
+        # evicts it. Wait the call out and hand the claim back, as AsyncReadWriteLock does.
+        abandoned = threading.Event()
+        acquire_future = self._submit(acquire, cancel_check=abandoned.is_set)
+        try:
+            await _wait_until_done(acquire_future)
+        except asyncio.CancelledError as cancellation:
+            # Stops a backend wait on another process's hold, which would otherwise outlast the caller by as long.
+            abandoned.set()
+            try:
+                await _drain_future(acquire_future)
+            except Timeout:
+                # Nothing was taken, so the caller's cancellation is the whole outcome.
+                raise cancellation from None
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            try:
+                await _drain_future(self._submit(self._leave_backend))
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                _raise_cancelled_error(cancellation, error)
+            raise
+        _future_result(acquire_future)
+
+    def _submit(
+        self, func: Callable[_P, _R], *args: _P.args, **kwargs: _P.kwargs
+    ) -> asyncio.Future[_BackendOutcome[_R]]:
+        loop = self._loop or asyncio.get_running_loop()
+        return loop.run_in_executor(self._executor, _capture_call, functools.partial(func, *args, **kwargs))
+
+
+class AsyncAcquireSoftReadWriteReturnProxy:
+    """Async context-aware object that releases an :class:`AsyncSoftReadWriteLock` on exit."""
+
+    def __init__(self, lock: AsyncSoftReadWriteLock) -> None:
+        self.lock = lock
+
+    async def __aenter__(self) -> AsyncSoftReadWriteLock:
+        return self.lock
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.lock.release()
+
+
+__all__ = [
+    "AsyncAcquireSoftReadWriteReturnProxy",
+    "AsyncSoftReadWriteLock",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_protocol.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_protocol.py
new file mode 100644
index 0000000000000000000000000000000000000000..565f9bcf7994c0808aa2d6d02a239cd96055b50d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_protocol.py
@@ -0,0 +1,638 @@
+"""
+The generation-log protocol behind :class:`~filelock.SoftReadWriteLock`.
+
+The lock's whole state is a sequence of immutable snapshots, ``gen/<N>``, each naming the writer and the readers that
+hold the lock at generation ``N``. Every transition is one atomic publication of the next snapshot: a participant reads
+the latest generation, derives the successor it wants, and links a fully written temporary file to ``gen/<N+1>``. The
+link fails if a peer got there first, so the participant re-reads and tries again. No step is ever half done: a crash
+leaves at most an unlinked temporary file, never a state that another participant must repair before it can proceed.
+
+Liveness rests on a nonce, not a clock. Each participant keeps ``holders/<token>`` and rewrites its nonce every
+heartbeat. A contender records the bytes it read there and the moment it read them on its own monotonic clock; a
+member whose bytes have not changed for ``stale_threshold`` is evicted by committing a snapshot without it. Two hosts
+never compare clocks, so a skewed file server or a suspended virtual machine cannot make a live holder look dead.
+
+The generation number is monotonic and unique to one transition within one incarnation of the log, so the generation at
+which a hold was granted fences it: a resource that rejects anything carrying a lower generation than the highest it has
+accepted refuses a holder that paused past its expiry and resumed. A random epoch file names the incarnation, so a
+participant that outlives a removal of the log reads the new one instead of continuing the old numbering into it.
+"""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["contextlib", "filelock._error", "filelock._identity", "math", "pathlib", "secrets"]
+
+import os
+import secrets
+from contextlib import suppress
+from dataclasses import dataclass
+from math import isfinite
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, Literal, Protocol
+
+from filelock._error import SoftFileLockProtocolError
+from filelock._identity import host_name
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+Mode = Literal["read", "write"]
+HeartbeatOutcome = Literal["ok", "lost", "transient"]
+
+_PROTOCOL: Final[str] = "filelock-rw/1"
+_GENERATION_DIGITS: Final[int] = 20
+_TOKEN_HEX_LENGTH: Final[int] = 32
+#: A snapshot line is ``reader=`` plus a token, so this bounds a hostile record without capping real reader counts.
+_MAX_RECORD_SIZE: Final[int] = 1 << 20
+#: Snapshots older than this many generations behind the latest are removed by whoever commits. The window is also how
+#: far ``latest`` probes past a gap before it trusts that nothing newer exists; ``gen/HEAD``, not the window, is what
+#: keeps a listing served further behind from passing an old generation off as the head.
+_RETAINED_GENERATIONS: Final[int] = 64
+_GENERATIONS_DIRECTORY: Final[str] = "gen"
+#: A random token created once per log: removing ``gen/`` removes it, so a participant can tell a log that was wiped and
+#: restarted from the one it remembers.
+_EPOCH_NAME: Final[str] = "epoch"
+#: The epoch plus a copy of the newest snapshot, renamed into place after each commit. NFS revalidates a file opened by
+#: name but may serve a listing from cache, so this is the head a stale client cannot miss; it may lag, never lead.
+_HEAD_NAME: Final[str] = "HEAD"
+_HOLDERS_DIRECTORY: Final[str] = "holders"
+_TEMPORARY_PREFIX: Final[str] = ".commit-"
+
+
+class TreeReplacedError(RuntimeError):
+    """
+    Raised by a ``Files`` implementation when a protocol directory is not a real directory (a symlink, a junction, a
+    file) or belongs to another account.
+    """
+
+
+class Files(Protocol):
+    """The filesystem operations the protocol runs on; :mod:`._storage` implements them over :mod:`os`."""
+
+    def read(self, path: str) -> bytes | None:
+        """The file's bytes, ``None`` when it does not exist, or ``b""`` when it is not a regular file."""
+
+    def create(self, path: str, data: bytes, *, durable: bool = False) -> tuple[int, int]:
+        """
+        Create the file exclusively with the whole record written; raise ``FileExistsError`` when it exists.
+
+        The returned device and inode (the kernel's identity for a file, independent of its name) let ``overwrite``
+        check that the name still leads to this file.
+
+        *durable* flushes it to stable storage first, for a record that outlives the host that wrote it: a generation a
+        crash left empty would wedge every other participant. A holder record dies with its writer, so it skips that.
+        """
+
+    def link(self, source: str, target: str) -> bool:
+        """Hard-link *source* to *target* without replacing; ``True`` when *target* names *source*'s file afterwards."""
+
+    def replace(self, source: str, target: str) -> bool:
+        """Rename *source* over *target* atomically; ``False`` when the platform refused because *target* is in use."""
+
+    def overwrite(self, path: str, data: bytes, identity: tuple[int, int]) -> bool:
+        """
+        Rewrite from offset zero the file ``create`` returned *identity* for.
+
+        ``False`` when *path* no longer leads to that file.
+        """
+
+    def unlink(self, path: str) -> None:
+        """Remove the file, tolerating one that is already gone."""
+
+    def listdir(self, path: str) -> list[str]:
+        """The names in the directory, or an empty list when it does not exist."""
+
+    def prepare(self, root: str, *, force: bool = False) -> None:
+        """
+        Create the protocol directories under *root*, refusing anything at those paths that is not a directory.
+
+        Done once per lock; *force* repeats it after a write found a directory missing.
+        """
+
+
+@dataclass(frozen=True)
+class Snapshot:
+    """The lock's state at one generation: which token writes, which tokens read."""
+
+    generation: int
+    writer: str | None
+    readers: frozenset[str]
+
+    @property
+    def members(self) -> frozenset[str]:
+        """Every token this generation names."""
+        return self.readers if self.writer is None else self.readers | {self.writer}
+
+    def encode(self) -> bytes:
+        lines = [_PROTOCOL, f"generation={self.generation}"]
+        if self.writer is not None:
+            lines.append(f"writer={self.writer}")
+        lines.extend(f"reader={token}" for token in sorted(self.readers))
+        return "".join(f"{line}\n" for line in lines).encode("ascii")
+
+
+def parse_snapshot(data: bytes) -> Snapshot | None:
+    """The snapshot a ``gen/<N>`` record encodes, or ``None`` when the record is malformed."""
+    if not data or len(data) > _MAX_RECORD_SIZE:
+        return None
+    try:
+        lines = data.decode("ascii").split("\n")
+    except UnicodeDecodeError:
+        return None
+    if lines[0] != _PROTOCOL or lines[-1]:
+        return None
+    generation: int | None = None
+    writer: str | None = None
+    readers: set[str] = set()
+    for line in lines[1:-1]:
+        key, _, value = line.partition("=")
+        if (
+            key == "generation"
+            and generation is None
+            and len(value) <= _GENERATION_DIGITS
+            and value.isdigit()
+            and str(int(value)) == value
+        ):
+            generation = int(value)
+        elif key == "writer" and writer is None and is_token(value):
+            writer = value
+        elif key == "reader" and is_token(value) and value not in readers:
+            readers.add(value)
+        else:
+            return None
+    return None if generation is None else Snapshot(generation=generation, writer=writer, readers=frozenset(readers))
+
+
+def is_token(value: str) -> bool:
+    """Whether *value* is a claim token: exactly 32 lowercase hex digits."""
+    return len(value) == _TOKEN_HEX_LENGTH and all(character in "0123456789abcdef" for character in value)
+
+
+def new_token() -> str:
+    """A fresh claim token."""
+    return secrets.token_hex(_TOKEN_HEX_LENGTH // 2)
+
+
+def encode_holder(token: str, nonce: str, lease: float) -> bytes:
+    """
+    The ``holders/<token>`` record; only the nonce changes between heartbeats, so the length stays constant.
+
+    *lease* is the writer's own ``stale_threshold``: a peer configured tighter must not read this holder's longer
+    heartbeat interval as death, so evictors wait the longer of their threshold and this one.
+    """
+    return (
+        f"{_PROTOCOL}\ntoken={token}\npid={os.getpid()}\nhost={host_name()}\nlease={float(lease)!r}\nnonce={nonce}\n"
+    ).encode("ascii")
+
+
+def holder_lease(record: bytes | None) -> float | None:
+    """The ``lease`` a holder record carries, or ``None`` when it has none (an older release) or it is malformed."""
+    try:
+        text = next(
+            line for line in (record or b"").decode("ascii").split("\n") if line.startswith("lease=")
+        ).removeprefix("lease=")
+        lease = float(text)
+    except (StopIteration, ValueError):  # UnicodeDecodeError is a ValueError
+        return None
+    # Only the exact spelling repr() writes: float() alone also takes "1_000", " 1", and non-ASCII digits.
+    return lease if isfinite(lease) and lease > 0 and repr(lease) == text else None
+
+
+class Ledger:
+    """
+    How long each observed value has stayed the same, measured on this observer's monotonic clock.
+
+    A value that has not changed for ``stale_threshold`` belongs to a participant that stopped refreshing it. The clock
+    is the observer's own and only ever measures the gap between two of its own observations, which is what lets two
+    hosts agree on liveness without agreeing on the time.
+    """
+
+    def __init__(self, clock: Callable[[], float]) -> None:
+        self._clock = clock
+        self._seen: dict[str, tuple[bytes | None, float]] = {}
+
+    def observe(self, key: str, value: bytes | None, *, asked: float | None = None) -> float:
+        """
+        Record *value* for *key* and return for how long it has stayed the same.
+
+        *asked* is the clock reading taken before the caller fetched *value*. An unchanged value counts as unchanged up
+        to *asked*, so a pause between the fetch and this call adds no time.
+        """
+        now = self._clock()
+        if (seen := self._seen.get(key)) is None or seen[0] != value:
+            self._seen[key] = (value, now)
+            return 0.0
+        return (now if asked is None else asked) - seen[1]
+
+    def forget(self, key: str) -> None:
+        self._seen.pop(key, None)
+
+    def retain(self, keys: set[str]) -> None:
+        """Drop every key not in *keys*: peers that left would otherwise stay in the ledger for the lock's lifetime."""
+        self._seen = {key: seen for key, seen in self._seen.items() if key in keys}
+
+
+class GenerationLog:
+    """The ordered snapshots under ``gen/``, found by listing and probing, advanced by linking the next one."""
+
+    def __init__(self, files: Files, lock_file: str, root: str) -> None:
+        self._files = files
+        self._lock_file = lock_file
+        self._directory = Path(root, _GENERATIONS_DIRECTORY)
+        self._epoch_path = str(self._directory / _EPOCH_NAME)
+        self._head_path = str(self._directory / _HEAD_NAME)
+        self._epoch: bytes | None = None
+        self._latest: Snapshot | None = None
+
+    def latest(self) -> Snapshot:
+        """
+        The newest snapshot.
+
+        Starts from the newest readable generation among those ``gen/HEAD``, the listing, or memory name, then probes
+        forward by name across the retained window. ``HEAD`` only names a generation, and that generation must still
+        read back: a committer stalled before its rename can leave ``HEAD`` on a generation compacted since. A
+        generation compacted between the listing and the read, and a hole left by a committer that died before it
+        compacted, are covered by the probe. Memory and ``HEAD`` are bound to the log's epoch, so a log wiped and
+        restarted is never continued from a generation it no longer holds. Only a log that names generations, now or as
+        remembered, of which none can be read is refused, because that is a client so far behind the log that nothing
+        it reads can be trusted.
+        """
+        # When everything the first pass named is gone, peers compacted past it while this client looked, or the log was
+        # replaced; one more pass settles whether this client cannot see the head at all.
+        if (latest := self._find()) is None and (latest := self._find()) is None:
+            raise SoftFileLockProtocolError(self._lock_file, None, "generation log names no readable snapshot")
+        self._latest = latest
+        return latest
+
+    def _find(self) -> Snapshot | None:
+        if (epoch := self._incarnation()) != self._epoch:
+            self._epoch, self._latest = epoch, None
+        named = set(self._list())
+        # Generation 0 is the empty log, which has no record to read back.
+        if self._latest is not None and self._latest.generation:
+            named.add(self._latest.generation)
+        if head := self._head_generation():
+            named.add(head)
+        for generation in sorted(named, reverse=True):
+            if (start := self._read(generation)) is not None:
+                # Compaction keeps the surviving generations contiguous, so the first missing name past a readable HEAD
+                # generation is the end; probing the whole window on every poll cost 64 failed opens.
+                return self._probe(start, patience=1 if generation == head else _RETAINED_GENERATIONS)
+        newest = max(named, default=0)
+        found = self._probe(Snapshot(generation=newest, writer=None, readers=frozenset()))
+        return found if found.generation > newest or not named else None
+
+    def _head_generation(self) -> int | None:
+        # HEAD is never flushed, so a crash can leave it unreadable; readers verify what it names anyway, so a torn one
+        # only sends them to the window probe.
+        if (record := self._head_record()) is None or (snapshot := parse_snapshot(record)) is None:
+            return None
+        return snapshot.generation
+
+    def _head_record(self) -> bytes | None:
+        if (data := self._files.read(self._head_path)) is None:
+            return None
+        # A HEAD from another epoch landed after its log was removed; a log whose epoch was never written runs without.
+        epoch, newline, record = data.partition(b"\n")
+        return record if self._valid_epoch() == epoch + newline else None
+
+    def _valid_epoch(self) -> bytes | None:
+        epoch = self._epoch
+        return epoch if epoch is not None and is_token(epoch.decode("ascii", "replace").removesuffix("\n")) else None
+
+    def _incarnation(self) -> bytes | None:
+        if (epoch := self._files.read(self._epoch_path)) is None:
+            # Exclusive creation, not a link: reading the log must keep working where os.link does not exist. A peer
+            # that reads the file before its token is written takes the empty value for the epoch, and its next commit
+            # sees the change and re-reads, so a partial read costs one retry.
+            try:
+                self._files.create(self._epoch_path, f"{new_token()}\n".encode("ascii"), durable=True)
+            except FileExistsError:
+                pass
+            except FileNotFoundError:
+                # No gen/ yet: there is no log to tell apart, and the first participant's prepare() creates it.
+                return None
+            epoch = self._files.read(self._epoch_path)
+        return epoch
+
+    def _list(self) -> list[int]:
+        listed = self._listed()
+        for generation in listed[:-_RETAINED_GENERATIONS]:
+            self._files.unlink(self._path(generation))
+        return listed[-_RETAINED_GENERATIONS:]
+
+    def _listed(self) -> list[int]:
+        # isdigit() alone admits Unicode digits: superscripts int() rejects, fullwidth ones it parses to another number.
+        return sorted(
+            int(name)
+            for name in self._files.listdir(str(self._directory))
+            if len(name) == _GENERATION_DIGITS and name.isascii() and name.isdigit()
+        )
+
+    def _probe(self, start: Snapshot, patience: int = _RETAINED_GENERATIONS) -> Snapshot:
+        latest = start
+        generation = start.generation
+        gap = 0
+        while gap < patience:
+            generation += 1
+            if (snapshot := self._read(generation)) is None:
+                gap += 1
+                continue
+            latest = snapshot
+            gap = 0
+        return latest
+
+    def _read(self, generation: int) -> Snapshot | None:
+        if (data := self._files.read(self._path(generation))) is None:
+            return None
+        if (snapshot := parse_snapshot(data)) is None or snapshot.generation != generation:
+            name = self._name(generation)
+            raise SoftFileLockProtocolError(self._lock_file, name, "malformed generation record")
+        return snapshot
+
+    def commit(self, successor: Snapshot) -> bool:
+        """
+        Publish *successor* as the next generation; ``False`` when a peer published that generation first.
+
+        The record is complete before it gets its public name, and a no-replace hard link is the compare-and-swap: only
+        one link to ``gen/<N+1>`` can ever succeed. The link's return code is not trusted, because an NFS retry can
+        report a link that did land as failed; the file's identity after the call is what decides. A log whose epoch
+        changed since the snapshot was read is a different log, so the commit is refused as lost and the caller
+        re-reads; that narrows a wipe racing this commit to the moment between the epoch check and the link. A slot
+        compaction freed is refused the same way, before the link and again after it, since a committer can stall in
+        between. After the link a surviving predecessor proves little: it may be a record another stalled committer
+        linked into its own freed slot and has yet to remove. A slot comes free once the log is a whole window past it,
+        and the head stays, so a record the listing or ``HEAD`` leads by a window is refused as well. A record refused
+        after it landed is removed when nothing was built on it. One that peers lead by less than a window stays, or its
+        slot would come free early.
+        """
+        if self._files.read(self._epoch_path) != self._epoch or not self._extends_the_log(successor.generation):
+            return False
+        if not self._publish(
+            self._path(successor.generation), data := successor.encode(), self._files.link, durable=True
+        ):
+            return False
+        lead = max([*self._listed(), self._head_generation() or 0]) - successor.generation
+        if lead >= _RETAINED_GENERATIONS or not self._extends_the_log(successor.generation):
+            if not 0 < lead < _RETAINED_GENERATIONS:
+                self._files.unlink(self._path(successor.generation))
+            return False
+        self._latest = successor
+        # Readers verify the generation HEAD names, so a failed rename costs a probe, not the commit. A late one would
+        # move HEAD back past later commits, so HEAD only ever moves forward.
+        with suppress(OSError):
+            if (
+                (epoch := self._valid_epoch()) is not None
+                and self._files.read(self._epoch_path) == epoch
+                and (self._head_generation() or 0) < successor.generation
+            ):
+                self._publish(self._head_path, epoch + data, self._files.replace, durable=False)
+        if (expired := successor.generation - _RETAINED_GENERATIONS - 1) > 0:
+            self._compact_through(expired)
+        return True
+
+    def _extends_the_log(self, generation: int) -> bool:
+        # Compaction removes oldest first, so a missing predecessor means compaction freed this slot. The first
+        # generation has none; a HEAD of this epoch means the log already moved past it.
+        if generation > 1:
+            return self._files.read(self._path(generation - 1)) is not None
+        return self._head_record() is None
+
+    def _publish(self, target: str, data: bytes, place: Callable[[str, str], bool], *, durable: bool) -> bool:
+        temporary = str(self._directory / f"{_TEMPORARY_PREFIX}{new_token()}")
+        try:
+            self._files.create(temporary, data, durable=durable)
+        except FileNotFoundError:
+            # No gen/: the log was removed, or nobody has prepared it yet. Either way there is nothing to publish into
+            # until a participant's prepare() creates it, and the caller re-reads whatever log exists by then.
+            return False
+        try:
+            return place(temporary, target)
+        finally:
+            self._files.unlink(temporary)
+
+    def _compact_through(self, expired: int) -> None:
+        # Oldest first, so survivors stay contiguous: a stalled committer's leftover would otherwise sit below a hole.
+        oldest = expired
+        while oldest > 1 and self._files.read(self._path(oldest - 1)) is not None:
+            oldest -= 1
+        for generation in range(oldest, expired + 1):
+            self._files.unlink(self._path(generation))
+
+    def _path(self, generation: int) -> str:
+        return str(self._directory / self._name(generation))
+
+    @staticmethod
+    def _name(generation: int) -> str:
+        return f"{generation:0{_GENERATION_DIGITS}d}"
+
+
+class Participant:
+    """
+    One acquisition, from publishing a claim through holding the lock to leaving.
+
+    ``advance`` is polled until it reports the lock granted, ``heartbeat`` runs on the holder's schedule, and ``leave``
+    commits the participant out. None of them sleep: the caller owns the deadline and the poll interval. The ledger and
+    the log outlive one acquisition: how long a peer's record has stayed unchanged is knowledge every attempt against
+    the same lock shares, or a caller whose attempts are each shorter than the stale threshold could never evict.
+    """
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # one value per protocol input; the lock builds this once per acquisition
+        self,
+        files: Files,
+        root: str,
+        mode: Mode,
+        *,
+        stale_threshold: float,
+        clock: Callable[[], float],
+        ledger: Ledger,
+        log: GenerationLog,
+    ) -> None:
+        self.token: Final[str] = new_token()
+        self.mode: Final[Mode] = mode
+        self.generation: int | None = None
+        self._files = files
+        self._root = root
+        self._stale_threshold = stale_threshold
+        self._clock = clock
+        self._ledger = ledger
+        self._log = log
+        self._holder = self._holder_path(self.token)
+        self._holder_identity: tuple[int, int] | None = None
+        self._entered = False
+        self._next_sweep = clock()
+
+    def publish(self) -> None:
+        """Create the holder record peers watch for liveness; it exists before the token appears in any snapshot."""
+        self._files.prepare(self._root)
+        self._create_holder()
+
+    def _create_holder(self) -> None:
+        try:
+            self._holder_identity = self._files.create(self._holder, self._record())
+        except FileNotFoundError:
+            # Removing the whole log takes the directories with it.
+            self._files.prepare(self._root, force=True)
+            self._holder_identity = self._files.create(self._holder, self._record())
+
+    def _record(self) -> bytes:
+        return encode_holder(self.token, new_token(), self._stale_threshold)
+
+    def advance(self) -> bool:
+        """
+        Take the next step toward holding the lock; ``True`` once the lock is granted.
+
+        A reader enters as soon as no live writer is named. A writer enters as soon as no live writer is named, which
+        blocks every new reader, then waits for the named readers to leave. Stale members are evicted in the same commit
+        that admits this participant, and a writer's final admission is itself a commit, so no admission can rest on a
+        snapshot a peer is about to supersede.
+        """
+        # A lost race is not a reason to wait: re-read and try again before handing the poll interval back to the
+        # caller.
+        for _ in range(4):
+            latest = self._log.latest()
+            self._keep_claim_fresh(latest)
+            self._sweep(latest)
+            stale = frozenset(token for token in latest.members - {self.token} if self._is_stale(token))
+            writer = None if latest.writer in stale else latest.writer
+            readers = latest.readers - stale
+            if not self._entered:
+                if writer is not None:
+                    # A live writer blocks entry in both modes; only an eviction is worth committing.
+                    if stale:
+                        self._commit(latest, writer, readers, stale)
+                    return False
+                writer, readers = (self.token, readers) if self.mode == "write" else (None, readers | {self.token})
+            granted = self.mode == "read" or not readers
+            if self._entered and not stale and not granted:
+                return False
+            if (generation := self._commit(latest, writer, readers, stale)) is None:
+                continue
+            self._entered = True
+            if granted:
+                self.generation = generation
+            return granted
+        return False
+
+    def _keep_claim_fresh(self, latest: Snapshot) -> None:
+        # The snapshot is the truth about membership: a commit the filesystem reported lost may have landed, and a peer
+        # may have evicted this participant while it waited to drain, so both directions are taken from it. A wait can
+        # outlast the stale threshold, so the nonce changes on every poll; a peer then never reads a patient contender
+        # as a corpse. A record that has gone missing was taken by an evictor or a sweeper that did, or by a removal of
+        # the whole log.
+        self._entered = self.token in latest.members
+        if not self._refresh_nonce():
+            with suppress(FileExistsError):
+                self._create_holder()
+
+    def _sweep(self, latest: Snapshot) -> None:
+        # A participant that crashed before its first commit leaves a record no snapshot names, and a commit that
+        # crashed between creating and unlinking its temporary file leaves that too. Neither blocks anyone, so they are
+        # collected on the same unchanged-for-a-threshold rule as a member, and only every half threshold at most.
+        if (now := self._clock()) < self._next_sweep:
+            return
+        self._next_sweep = now + self._stale_threshold / 2
+        watched = set(latest.members)
+        holders = Path(self._root, _HOLDERS_DIRECTORY)
+        for name in self._files.listdir(str(holders)):
+            if name != self.token and name not in latest.members and is_token(name):
+                watched.add(key := f"holder:{name}")
+                self._collect(key, str(holders / name))
+        generations = Path(self._root, _GENERATIONS_DIRECTORY)
+        for name in self._files.listdir(str(generations)):
+            if name.startswith(_TEMPORARY_PREFIX):
+                watched.add(key := f"temporary:{name}")
+                self._collect(key, str(generations / name))
+        self._ledger.retain(watched)
+
+    def _collect(self, key: str, path: str) -> None:
+        if self._unchanged_for_its_lease(key, path):
+            self._files.unlink(path)
+            self._ledger.forget(key)
+
+    def _commit(
+        self, latest: Snapshot, writer: str | None, readers: frozenset[str], stale: frozenset[str]
+    ) -> int | None:
+        successor = Snapshot(generation=latest.generation + 1, writer=writer, readers=readers)
+        if not self._log.commit(successor):
+            return None
+        for token in stale:
+            self._files.unlink(self._holder_path(token))
+            self._ledger.forget(token)
+        return successor.generation
+
+    def _is_stale(self, token: str) -> bool:
+        return self._unchanged_for_its_lease(token, self._holder_path(token))
+
+    def _unchanged_for_its_lease(self, key: str, path: str) -> bool:
+        asked = self._clock()
+        record = self._files.read(path)
+        return self._ledger.observe(key, record, asked=asked) >= max(self._stale_threshold, holder_lease(record) or 0.0)
+
+    def _holder_path(self, token: str) -> str:
+        return str(Path(self._root, _HOLDERS_DIRECTORY, token))
+
+    def _refresh_nonce(self) -> bool:
+        if (identity := self._holder_identity) is None:
+            return False
+        return self._files.overwrite(self._holder, self._record(), identity)
+
+    def heartbeat(self) -> tuple[HeartbeatOutcome, OSError | None]:
+        """
+        Refresh the nonce and confirm the latest snapshot still names this participant.
+
+        ``lost`` means a peer evicted this participant or removed its holder record: the lock is no longer held, and the
+        holder must stop using what it protects. ``transient`` is a filesystem error refreshing the nonce, worth
+        retrying on the next tick. A failure to read the log or to sweep decides nothing about this holder's liveness,
+        so it is not counted against it.
+        """
+        try:
+            if not self._refresh_nonce():
+                return "lost", None
+        except TreeReplacedError:
+            return "lost", None
+        except OSError as error:
+            return "transient", error
+        try:
+            latest = self._log.latest()
+            self._sweep(latest)
+        except (OSError, TreeReplacedError):
+            return "ok", None
+        return ("ok" if self.token in latest.members else "lost"), None
+
+    def leave(self) -> None:
+        """Commit this participant out of the latest snapshot, then remove its holder record."""
+        # The record goes even when the log cannot be read: a contender that never entered then leaves nothing behind,
+        # and a member still named ages out the same way with or without one.
+        # A tree that was swapped out leaves no record this participant can reach, so there is nothing to commit out of.
+        with suppress(TreeReplacedError):
+            try:
+                while self.token in (latest := self._log.latest()).members:
+                    successor = Snapshot(
+                        generation=latest.generation + 1,
+                        writer=None if latest.writer == self.token else latest.writer,
+                        readers=latest.readers - {self.token},
+                    )
+                    if self._log.commit(successor):
+                        break
+            finally:
+                self._entered = False
+                self.generation = None
+                self._files.unlink(self._holder)
+
+
+__all__ = [
+    "Files",
+    "GenerationLog",
+    "HeartbeatOutcome",
+    "Ledger",
+    "Mode",
+    "Participant",
+    "Snapshot",
+    "TreeReplacedError",
+    "encode_holder",
+    "holder_lease",
+    "is_token",
+    "new_token",
+    "parse_snapshot",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_storage.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_storage.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6ff6c64efab66b9879c35b714ce22a97e1c4cb5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_storage.py
@@ -0,0 +1,278 @@
+"""The :class:`~._protocol.Files` implementation over :mod:`os`."""
+
+from __future__ import annotations
+
+__lazy_modules__ = ["filelock._soft_rw._protocol", "filelock._strict", "filelock._util", "pathlib"]
+
+import errno
+import os
+import stat
+import sys
+import time
+from contextlib import contextmanager, suppress
+from errno import ELOOP, ENOENT, ENOTDIR, ENXIO, ESTALE
+from pathlib import Path
+from typing import TYPE_CHECKING, Final
+
+from filelock._soft_rw._protocol import (
+    _GENERATIONS_DIRECTORY,
+    _HOLDERS_DIRECTORY,
+    _MAX_RECORD_SIZE,
+    TreeReplacedError,
+)
+from filelock._strict import _link_no_follow, _pin_directories, _raise_if_hard_links_unsupported
+from filelock._util import ensure_directory_exists, foreign_directory_owner, write_all
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+_O_NOFOLLOW: Final[int] = getattr(os, "O_NOFOLLOW", 0)
+#: Probed once at import, as :mod:`filelock._strict` does, because a per-call check flips when a test mocks the
+#: function. The set lists os.rename, whose implementation os.replace shares.
+_SUPPORTS_DIR_FD: Final[bool] = (
+    hasattr(os, "link")
+    and {os.link, os.open, os.stat, os.mkdir, os.rename, os.unlink} <= os.supports_dir_fd
+    and os.scandir in os.supports_fd
+)
+#: Windows opens descriptors in text mode by default, which rewrites newlines; every record here is exact bytes.
+_O_BINARY: Final[int] = getattr(os, "O_BINARY", 0)
+#: ESTALE is what an NFS client reports for a file a peer unlinked out from under its cached handle: gone, not broken.
+_MISSING_ERRNOS: Final[frozenset[int]] = frozenset({ENOENT, ESTALE})
+#: Windows refuses an open with EACCES while another process is deleting the file or holds it open without sharing;
+#: both clear within moments, so an open is retried this long before the refusal is taken as real.
+_WINDOWS_OPEN_GRACE: Final[float] = 0.5
+
+
+class OsFiles:
+    """Record files under a lock's protocol root, opened without following symlinks and owned by this UID alone."""
+
+    def __init__(self, lock_file: str) -> None:
+        self._lock_file = lock_file
+        self._prepared = False
+        self._identities: dict[str, tuple[int, int]] = {}
+
+    def read(self, path: str) -> bytes | None:
+        # O_NONBLOCK keeps an open of a FIFO planted at the path from blocking; the regular-file check below rejects it.
+        if (fd := self._open(path, os.O_RDONLY | _O_NOFOLLOW | getattr(os, "O_NONBLOCK", 0) | _O_BINARY)) is None:
+            return None
+        try:
+            if not stat.S_ISREG(os.fstat(fd).st_mode):
+                return b""
+            chunks: list[bytes] = []
+            remaining = _MAX_RECORD_SIZE + 1
+            while remaining > 0 and (chunk := os.read(fd, remaining)):
+                chunks.append(chunk)
+                remaining -= len(chunk)
+            return b"".join(chunks)
+        finally:
+            os.close(fd)
+
+    def create(self, path: str, data: bytes, *, durable: bool = False) -> tuple[int, int]:
+        with self._relative(path) as (name, dir_fd):
+            fd = os.open(name, os.O_WRONLY | os.O_CREAT | os.O_EXCL | _O_NOFOLLOW | _O_BINARY, 0o600, dir_fd=dir_fd)
+        try:
+            write_all(fd, data)
+            if durable:
+                os.fsync(fd)
+            created = os.fstat(fd)
+        except BaseException:
+            os.close(fd)
+            # The name is unique to this call, so removing it cannot take a record from anyone else.
+            self.unlink(path)
+            raise
+        os.close(fd)
+        return created.st_dev, created.st_ino
+
+    def link(self, source: str, target: str) -> bool:
+        failure: NotImplementedError | OSError | None = None
+        with self._relative(source) as (source_name, source_fd), self._relative(target) as (target_name, target_fd):
+            try:
+                _link_no_follow(source_name, target_name, src_dir_fd=source_fd, dst_dir_fd=target_fd)
+            except FileExistsError:
+                pass
+            except (NotImplementedError, OSError) as error:
+                _raise_if_hard_links_unsupported(self._lock_file, error)
+                failure = error
+            # The file's identity decides, not the call's result: an NFS retransmit can report a link that landed as
+            # failed, and an EEXIST can be this very link answered twice. Any other error on a link that did not land is
+            # a fault, not a peer winning the race, and a retry would spin.
+            if (identity := _identity(source_name, source_fd)) is not None and identity == _identity(
+                target_name, target_fd
+            ):
+                return True
+        if failure is not None:
+            raise failure
+        return False
+
+    def replace(self, source: str, target: str) -> bool:
+        try:
+            with self._relative(source) as (source_name, source_fd), self._relative(target) as (target_name, target_fd):
+                os.replace(source_name, target_name, src_dir_fd=source_fd, dst_dir_fd=target_fd)
+        except PermissionError:
+            # Windows refuses to rename over a file a reader holds open; callers tolerate a target one rename behind.
+            return False
+        return True
+
+    def overwrite(self, path: str, data: bytes, identity: tuple[int, int]) -> bool:
+        # O_NONBLOCK keeps an open of a FIFO (a named pipe) at the path from blocking, as in read. With no reader the
+        # open fails with ENXIO.
+        try:
+            fd = self._open(path, os.O_WRONLY | _O_NOFOLLOW | getattr(os, "O_NONBLOCK", 0) | _O_BINARY)
+        except OSError as error:
+            if error.errno != ENXIO:
+                raise
+            return False  # pragma: needs fifo
+        if fd is None:
+            return False
+        try:
+            # O_NOFOLLOW refuses a symlink but not a hard link (a second name for the same file) or another file renamed
+            # over the name, and a write through either lands in a file that is not the record. The protocol does not
+            # link holder records, so a second name marks a file that inherited a removed record's inode number.
+            opened = os.fstat(fd)
+            if not stat.S_ISREG(opened.st_mode) or (opened.st_dev, opened.st_ino) != identity or opened.st_nlink != 1:
+                return False
+            write_all(fd, data)
+        finally:
+            os.close(fd)
+        return True
+
+    def unlink(self, path: str) -> None:
+        try:
+            with self._relative(path) as (name, dir_fd):
+                os.unlink(name, dir_fd=dir_fd)
+        except OSError as error:
+            # Windows refuses to remove a file another process holds open; the record then outlives its owner until
+            # that process exits, which only delays the cleanup a later participant repeats.
+            if error.errno not in _MISSING_ERRNOS and not isinstance(error, PermissionError):
+                raise
+
+    def listdir(self, path: str) -> list[str]:
+        try:
+            with self._directory(path) as dir_fd, os.scandir(path if dir_fd is None else dir_fd) as entries:
+                return [entry.name for entry in entries]
+        except FileNotFoundError:
+            return []
+
+    def prepare(self, root: str, *, force: bool = False) -> None:
+        if self._prepared and not force:
+            return
+        if force:
+            self._identities.clear()
+        ensure_directory_exists(root)
+        for directory, depth in (
+            (Path(root), 0),
+            (Path(root, _GENERATIONS_DIRECTORY), 1),
+            (Path(root, _HOLDERS_DIRECTORY), 1),
+        ):
+            with self._relative(str(directory), depth) as (name, dir_fd):
+                with suppress(FileExistsError):
+                    os.mkdir(name, 0o700, dir_fd=dir_fd)
+                # mkdir has no O_NOFOLLOW, so check what the name resolves to before the lock creates anything in it.
+                found = os.stat(name, dir_fd=dir_fd, follow_symlinks=False)
+                parent = directory.parent.stat() if dir_fd is None else os.fstat(dir_fd)
+            if (
+                not stat.S_ISDIR(found.st_mode)
+                or getattr(found, "st_file_attributes", 0) & stat.FILE_ATTRIBUTE_REPARSE_POINT
+            ):
+                msg = f"{directory} exists but is not a directory or is a symlink; refusing to use it"
+                raise TreeReplacedError(msg)
+            owner = foreign_directory_owner(found, parent)
+            if owner is not None:  # pragma: needs foreign-sticky-tmp
+                msg = f"{directory} belongs to uid {owner}, not to this process's account or the parent's owner"
+                raise TreeReplacedError(msg)
+            self._identities[str(directory)] = found.st_dev, found.st_ino
+        self._prepared = True
+
+    def _open(self, path: str, flags: int) -> int | None:
+        # Missing is the one answer a caller acts on without raising. A refused open is real on POSIX, where nothing
+        # this lock does makes its own records unreadable; on Windows it is usually another process mid-delete or
+        # holding the file without sharing, so it is retried through a short grace before it counts, and a file still
+        # refusing after that has been in delete-pending for longer than any deletion takes, so it is on its way out:
+        # missing.
+        deadline: float | None = None
+        while True:
+            if isinstance(opened := self._attempt_open(path, flags), int):
+                return opened
+            if opened.errno in _MISSING_ERRNOS:
+                return None
+            if not isinstance(opened, PermissionError) or sys.platform != "win32":
+                raise opened
+            if deadline is None:  # pragma: win32 cover
+                deadline = time.monotonic() + _WINDOWS_OPEN_GRACE
+            elif time.monotonic() >= deadline:  # pragma: win32 cover
+                return None
+            time.sleep(0.002)  # pragma: win32 cover
+
+    def _attempt_open(self, path: str, flags: int) -> int | OSError:
+        try:
+            with self._relative(path) as (name, dir_fd):
+                return os.open(name, flags, dir_fd=dir_fd)
+        except OSError as error:
+            return error
+
+    @contextmanager
+    def _relative(self, path: str, depth: int = 2) -> Generator[tuple[str, int | None]]:
+        directory, name = os.path.split(path)
+        with self._directory(directory, depth) as dir_fd:
+            yield (path if dir_fd is None else name), dir_fd
+
+    @contextmanager
+    def _directory(self, path: str, depth: int = 2) -> Generator[int | None]:
+        # O_NOFOLLOW applies to the last path component. The check prepare() made on <root> and <root>/gen holds until a
+        # process that can write the lock's directory renames the tree aside and puts one with a symlinked gen in its
+        # place. Each call therefore opens the root and then the record's directory without following symlinks and
+        # works inside what it opened. No descriptor outlives the call, so a later call finds a log removed and started
+        # again by name, as before. None means descriptors cannot anchor a call and the call uses the whole path.
+        if depth and _SUPPORTS_DIR_FD:  # pragma: needs link-dir-fd
+            with self._relative(path, depth - 1) as (name, parent_fd):
+                try:
+                    fd = os.open(name, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | _O_NOFOLLOW, dir_fd=parent_fd)
+                except OSError as error:
+                    # NetBSD reports EFTYPE rather than ELOOP when O_NOFOLLOW refuses a symlink.
+                    if error.errno not in {ELOOP, ENOTDIR, getattr(errno, "EFTYPE", ELOOP)}:
+                        raise
+                    msg = f"{path} is not a directory or is a symlink; refusing to use it"
+                    raise TreeReplacedError(msg) from error
+                try:
+                    self._admit(fd, path, parent_fd)
+                except BaseException:
+                    os.close(fd)
+                    raise
+            try:
+                yield fd
+            finally:
+                os.close(fd)
+        else:
+            # Without dir_fd, hold each of those directories open instead, so no process can rename or replace one.
+            try:
+                pins = _pin_directories(*[Path(path), *Path(path).parents][:depth][::-1])
+            except NotADirectoryError as error:  # pragma: win32 cover
+                msg = f"{error.filename} is not a directory or is a symlink; refusing to use it"
+                raise TreeReplacedError(msg) from error
+            with pins:
+                yield None
+
+    def _admit(self, fd: int, path: str, parent_fd: int | None) -> None:  # pragma: needs link-dir-fd
+        # A directory other than the one prepare() checked may belong to another account: the tree can be renamed aside
+        # and recreated while this object lives, and the ownership check has to hold for what is opened now.
+        found = os.fstat(fd)
+        if (found.st_dev, found.st_ino) == self._identities.get(path):
+            return
+        parent = os.fstat(parent_fd) if parent_fd is not None else Path(path).parent.stat()
+        if (owner := foreign_directory_owner(found, parent)) is not None:  # pragma: needs foreign-sticky-tmp
+            msg = f"{path} belongs to uid {owner}, not to this process's account or the parent's owner"
+            raise TreeReplacedError(msg)
+        self._identities[path] = found.st_dev, found.st_ino
+
+
+def _identity(path: str, dir_fd: int | None) -> tuple[int, int] | None:
+    try:
+        st = os.stat(path, dir_fd=dir_fd, follow_symlinks=False)
+    except OSError:
+        return None
+    return st.st_dev, st.st_ino
+
+
+__all__ = [
+    "OsFiles",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_sync.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..aa2e891516cb38f9027cfd840a4db758abde3390
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_soft_rw/_sync.py
@@ -0,0 +1,793 @@
+"""Cross-process and cross-host reader/writer lock over a generation log of immutable snapshots."""
+
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "filelock._error",
+    "filelock._lease",
+    "filelock._soft_rw._protocol",
+    "filelock._soft_rw._storage",
+    "math",
+]
+
+import atexit
+import os
+import threading
+import time
+from contextlib import contextmanager, suppress
+from dataclasses import dataclass
+from math import isfinite
+from typing import TYPE_CHECKING, ClassVar, Final
+from weakref import WeakValueDictionary
+
+from filelock._api import (
+    AcquireReturnProxy,
+    _acquire_thread_lock,
+    _canonical,
+    _check_timeout_max,
+    _ensure_current_process,
+    _register_fork_class,
+    _register_fork_object,
+    _resolve_read_write_timeout,
+    _seconds,
+    _timeout_behavior,
+)
+from filelock._error import Timeout
+from filelock._lease import LeaseCompromise
+from filelock._soft_rw._protocol import GenerationLog, Ledger, Mode, Participant
+from filelock._soft_rw._storage import OsFiles
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Generator
+
+    from filelock._lease import CompromiseReason
+
+_ALL_INSTANCES: Final[WeakValueDictionary[int, SoftReadWriteLock]] = WeakValueDictionary()
+_ALL_INSTANCES_LOCK: threading.Lock = threading.Lock()
+
+
+class _SoftRWMeta(type):
+    _instances: WeakValueDictionary[str, SoftReadWriteLock]
+    _instances_lock: threading.RLock
+    _instances_under_construction: set[str]
+
+    def __call__(  # ruff:ignore[too-many-arguments]  # forwards the public constructor's documented parameters
+        cls,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,
+        heartbeat_interval: float = 30.0,
+        stale_threshold: float | None = None,
+        poll_interval: float = 0.25,
+        on_compromise: Callable[[LeaseCompromise], None] | None = None,
+    ) -> SoftReadWriteLock:
+        _ensure_current_process()
+        timeout = _seconds("timeout", timeout)
+        # Passed through only when set, so a subclass that declares its own constructor without it keeps working.
+        extra = {} if on_compromise is None else {"on_compromise": on_compromise}
+        if not is_singleton:
+            return super().__call__(
+                lock_file,
+                timeout,
+                blocking=blocking,
+                is_singleton=is_singleton,
+                heartbeat_interval=heartbeat_interval,
+                stale_threshold=stale_threshold,
+                poll_interval=poll_interval,
+                **extra,
+            )
+
+        # Keyed like the log root, so one instance never spans two logs.
+        normalized = _canonical(lock_file)
+        with cls._instances_lock:
+            instance = cls._instances.get(normalized)
+            if instance is None:
+                if normalized in cls._instances_under_construction:
+                    msg = f"Singleton lock construction is already active for {lock_file!s}"
+                    raise RuntimeError(msg)
+                construction_pid = os.getpid()
+                construction_registry = cls._instances_under_construction
+                construction_registry.add(normalized)
+                try:
+                    instance = super().__call__(
+                        lock_file,
+                        timeout,
+                        blocking=blocking,
+                        is_singleton=is_singleton,
+                        heartbeat_interval=heartbeat_interval,
+                        stale_threshold=stale_threshold,
+                        poll_interval=poll_interval,
+                        **extra,
+                    )
+                finally:
+                    construction_registry.discard(normalized)
+                if os.getpid() != construction_pid:  # pragma: needs fork
+                    msg = "Lock construction cannot continue after fork; construct a new lock in the child"
+                    raise RuntimeError(msg)
+                cls._instances[normalized] = instance
+            elif (
+                _timeout_behavior(instance.timeout, any_negative=False)
+                != _timeout_behavior(timeout, any_negative=False)
+                or instance.blocking != blocking
+            ):
+                msg = (
+                    f"Singleton lock created with timeout={instance.timeout}, blocking={instance.blocking},"
+                    f" cannot be changed to timeout={timeout}, blocking={blocking}"
+                )
+                raise ValueError(msg)
+            elif on_compromise is not None and instance._on_compromise != on_compromise:  # ruff: ignore[private-member-access]  # the metaclass owns the singleton it compares
+                # A tuning difference keeps the first caller's values; a different loss callback is a different safety
+                # contract, and returning the cached instance would silently drop it.
+                msg = f"Singleton lock created with a different on_compromise callback for {lock_file!s}"
+                raise ValueError(msg)
+            else:
+                _validate_intervals(heartbeat_interval, stale_threshold, poll_interval)
+            return instance
+
+
+class SoftReadWriteLock(metaclass=_SoftRWMeta):
+    """
+    Cross-process and cross-host reader/writer lock for shared filesystems.
+
+    Use this class instead of :class:`~filelock.ReadWriteLock` when the lock file lives on a network filesystem (NFS,
+    Lustre, HPC cluster shared storage). ``ReadWriteLock`` is backed by SQLite and cannot run on NFS because SQLite's
+    ``fcntl`` locking is unreliable there.
+
+    The lock's state is a log of immutable snapshots under ``foo.lock.rw/gen/<N>``, each naming the writer and the
+    readers holding the lock at generation ``N``. Every acquire, release, and eviction publishes the next snapshot with
+    one atomic no-replace hard link, so no transition can be left half done by a crash on any host. Each participant
+    also keeps ``foo.lock.rw/holders/<token>``, a record whose nonce a daemon heartbeat thread rewrites every
+    ``heartbeat_interval`` seconds. A contender evicts a member whose record has not changed for ``stale_threshold``
+    seconds of the contender's own monotonic clock; no clock is ever compared across hosts, so skew between hosts or
+    against the file server cannot make a live holder look dead.
+
+    Writer acquire is writer-preferring: a writer enters the snapshot as soon as no live writer is named, which blocks
+    any new reader, then waits for the named readers to leave. Writer starvation is impossible.
+
+    An expired holder is not fenced by the lock: a process paused past ``stale_threshold`` resumes believing it holds
+    the lock until its next heartbeat reports the loss through ``on_compromise``. :attr:`generation` is a monotonic
+    fencing token for the protected resource: a store that rejects writes carrying a lower generation than the highest
+    it has accepted refuses such a holder.
+
+    Reentrancy, upgrade/downgrade rules, thread pinning, and singleton caching by canonical path match
+    :class:`~filelock.ReadWriteLock`.
+
+    Forking invalidates the inherited instance in the child so the child cannot double-own the lock with its parent;
+    ``release()`` on that instance is a no-op, and the child must construct a new instance if it needs a lock.
+
+    Trust boundary: protects against same-UID non-cooperating processes (one host or cross-host) and same-host
+    different-UID users via ``0o600`` / ``0o700`` permissions. Does not protect against root compromise or multi-tenant
+    mounts where hostile co-tenants share the UID.
+
+    :param lock_file: path to the lock file; the protocol directory lives next to it as ``<lock_file>.rw``
+    :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+    :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately on contention
+    :param is_singleton: if ``True``, reuse existing instances for the same canonical path
+    :param heartbeat_interval: seconds between heartbeat refreshes; default 30 s
+    :param stale_threshold: seconds a holder record may stay unchanged before a contender evicts it; defaults to
+        ``3 * heartbeat_interval``, matching etcd's ``LeaseKeepAlive`` convention
+    :param poll_interval: seconds between acquire retries under contention; default 0.25 s
+    :param on_compromise: called from the heartbeat thread with a :class:`~filelock.LeaseCompromise` when the hold is
+        lost: a peer evicted it, or refreshes failed for long enough that a peer could have
+
+    .. versionadded:: 3.27.0
+
+    .. versionchanged:: 3.33.0
+
+        The on-disk protocol is a generation log; earlier releases cannot share a lock path with this one.
+
+    """
+
+    _instances: WeakValueDictionary[str, SoftReadWriteLock] = WeakValueDictionary()
+    _instances_lock = threading.RLock()
+    _instances_under_construction: ClassVar[set[str]] = set()
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        """Give each lock subclass its own singleton registry and lock."""
+        super().__init_subclass__(**kwargs)
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = threading.RLock()
+        cls._instances_under_construction = set()
+        _register_fork_class(cls)
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+        is_singleton: bool = True,  # ruff:ignore[unused-method-argument]  # consumed by _SoftRWMeta.__call__
+        heartbeat_interval: float = 30.0,
+        stale_threshold: float | None = None,
+        poll_interval: float = 0.25,
+        on_compromise: Callable[[LeaseCompromise], None] | None = None,
+    ) -> None:
+        self._creator_pid = os.getpid()
+        heartbeat_interval, stale_threshold, poll_interval = _validate_intervals(
+            heartbeat_interval, stale_threshold, poll_interval
+        )
+
+        self.lock_file: str = os.fspath(lock_file)
+        self.timeout: float = timeout
+        self.blocking: bool = blocking
+        self.heartbeat_interval: float = heartbeat_interval
+        self.stale_threshold: float = stale_threshold
+        self.poll_interval: float = poll_interval
+
+        # Resolved once: a relative lock path must keep naming the same log after the process changes directory. The
+        # final component stays unresolved, as in 4.0.12, so every release shares one log on a symlinked lock path.
+        self._root = f"{_canonical(self.lock_file)}.rw"
+        self._files = OsFiles(self.lock_file)
+        self._ledger = Ledger(time.monotonic)
+        self._log = GenerationLog(self._files, self.lock_file, self._root)
+        self._on_compromise = on_compromise
+        self._locks = _Locks(internal=threading.Lock(), transaction=threading.Lock())
+        self._hold: _Hold | None = None
+        self._compromise: LeaseCompromise | None = None
+        self._closed: bool = False
+
+        with _ALL_INSTANCES_LOCK:
+            _ALL_INSTANCES[id(self)] = self
+        _register_fork_object(self)
+
+    @classmethod
+    def _reset_class_after_fork(cls) -> None:  # pragma: forked child
+        global _ALL_INSTANCES_LOCK  # ruff:ignore[global-statement]  # rebinds the module lock to a fresh one in the fork child
+        _ALL_INSTANCES_LOCK = threading.Lock()
+        cls._instances = WeakValueDictionary()
+        cls._instances_lock = threading.RLock()
+        cls._instances_under_construction = set()
+
+    @property
+    def generation(self) -> int | None:
+        """
+        The generation at which the current hold was granted, or ``None`` when no lock is held.
+
+        Generations are monotonic across all participants and hosts, so this is a fencing token: pass it to the
+        protected resource and have the resource reject any operation carrying a lower generation than the highest it
+        has accepted. That refuses a holder that paused past ``stale_threshold``, was evicted, and resumed. Removing the
+        ``<lock_file>.rw`` directory starts a new log whose generations begin again at 1.
+
+        .. versionadded:: 3.33.0
+
+        """
+        with self._locks.internal:
+            return None if self._hold is None else self._hold.participant.generation
+
+    @property
+    def compromise(self) -> LeaseCompromise | None:
+        """
+        How the current hold was lost, or ``None`` while it stands.
+
+        Set by the heartbeat thread once a peer has evicted this holder or refreshes have failed for long enough that a
+        peer could have. The holder should stop using the protected resource when it is set. Until the lost hold is
+        released, acquiring on this instance raises :class:`RuntimeError` instead of joining it.
+
+        .. versionadded:: 3.33.0
+
+        """
+        with self._locks.internal:
+            return self._compromise
+
+    @contextmanager
+    def read_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> Generator[None]:
+        """
+        Context manager that acquires and releases a shared read lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :raises RuntimeError: if a write lock is already held on this instance
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self.acquire_read(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            self.release()
+
+    @contextmanager
+    def write_lock(self, timeout: float | None = None, *, blocking: bool | None = None) -> Generator[None]:
+        """
+        Context manager that acquires and releases an exclusive write lock.
+
+        Falls back to instance defaults for *timeout* and *blocking* when ``None``.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately; ``None`` uses the instance default
+
+        :raises RuntimeError: if a read lock is already held, or a write lock is held by a different thread
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+
+        """
+        self.acquire_write(timeout, blocking=blocking)
+        try:
+            yield
+        finally:
+            self.release()
+
+    def acquire_read(self, timeout: float | None = None, *, blocking: bool | None = None) -> AcquireReturnProxy:
+        """
+        Acquire a shared read lock.
+
+        If this instance already holds a read lock, the lock level is incremented (reentrant). Attempting to acquire a
+        read lock while holding a write lock raises :class:`RuntimeError` (downgrade not allowed). On the 0→1
+        transition the reader publishes its holder record, enters the next snapshot once no live writer is named, and
+        starts a daemon heartbeat thread that rewrites the record's nonce every ``heartbeat_interval`` seconds so peers
+        on other hosts do not evict it.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block
+            indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable;
+            ``None`` uses the instance default
+
+        :returns: a proxy that can be used as a context manager to release the lock
+
+        :raises RuntimeError: if a write lock is already held on this instance, if this instance was invalidated by
+            :func:`os.fork`, or if :meth:`close` was called
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+        :raises SoftFileLockProtocolError: if a snapshot cannot be read without risking overlap, or the filesystem
+            refuses the no-replace hard links the protocol commits with
+
+        """
+        return self._acquire("read", timeout, blocking=blocking)
+
+    def acquire_write(self, timeout: float | None = None, *, blocking: bool | None = None) -> AcquireReturnProxy:
+        """
+        Acquire an exclusive write lock.
+
+        If this instance already holds a write lock from the same thread, the lock level is incremented (reentrant).
+        Attempting to acquire a write lock while holding a read lock raises :class:`RuntimeError` (upgrade not
+        allowed). Write locks are pinned to the acquiring thread: a different thread trying to re-enter also raises
+        :class:`RuntimeError`.
+
+        A writer enters the next snapshot as its writer as soon as no live writer is named, which blocks every new
+        reader on every host, then waits for the readers that snapshot names to leave. Writer starvation is impossible:
+        new readers see the named writer and wait behind it.
+
+        :param timeout: maximum wait time in seconds, or ``None`` to use the instance default; ``-1`` means block
+            indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable;
+            ``None`` uses the instance default
+
+        :returns: a proxy that can be used as a context manager to release the lock
+
+        :raises RuntimeError: if a read lock is already held, if a write lock is held by a different thread, if this
+            instance was invalidated by :func:`os.fork`, or if :meth:`close` was called
+        :raises Timeout: if the lock cannot be acquired within *timeout* seconds
+        :raises TypeError: if *timeout* is a :class:`bool` or not a real number
+        :raises ValueError: if a blocking call gets a ``nan`` *timeout* or a negative one other than ``-1``
+        :raises SoftFileLockProtocolError: if a snapshot cannot be read without risking overlap, or the filesystem
+            refuses the no-replace hard links the protocol commits with
+
+        """
+        return self._acquire("write", timeout, blocking=blocking)
+
+    @classmethod
+    def get_lock(
+        cls,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        *,
+        blocking: bool = True,
+    ) -> SoftReadWriteLock:
+        """
+        Return the singleton :class:`SoftReadWriteLock` for *lock_file*.
+
+        :param lock_file: path to the lock file; the protocol directory lives next to it as ``<lock_file>.rw``
+        :param timeout: maximum wait time in seconds; ``-1`` means block indefinitely
+        :param blocking: if ``False``, raise :class:`~filelock.Timeout` immediately when the lock is unavailable
+
+        :returns: the singleton lock instance
+
+        :raises ValueError: if an instance already exists for this path with different *timeout* or *blocking* values
+
+        """
+        return cls(lock_file, timeout, blocking=blocking)
+
+    def close(self) -> None:
+        """
+        Release any held lock and mark the instance closed.
+
+        Idempotent. After calling this method the instance can no longer acquire locks — subsequent acquires raise
+        :class:`RuntimeError`, and so does an acquire another thread is still waiting in, which gives up its claim
+        instead of taking the lock. A fork-invalidated instance is closed without raising.
+        """
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            return
+        # Closed first, under the lock an acquire publishes its hold under: an acquire still waiting then sees the flag
+        # and leaves instead of publishing, and one that published before it is released below.
+        with self._locks.internal:
+            self._closed = True
+        self.release(force=True)
+
+    def release(self, *, force: bool = False) -> None:
+        """
+        Release one level of the current lock.
+
+        When the lock level reaches zero the heartbeat thread is stopped, the participant is committed out of the next
+        snapshot, and its holder record is removed. On a fork-invalidated instance (that is, the child of a
+        :func:`os.fork` call made while the parent held a lock) this method is a no-op so inherited ``with`` blocks can
+        unwind cleanly in the child.
+
+        :param force: if ``True``, release the lock completely regardless of the current lock level
+
+        :raises RuntimeError: if no lock is currently held and *force* is ``False``, or if the calling thread holds no
+            level of the current lock and *force* is ``False``
+
+        """
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            return
+        self._release(threading.get_ident(), force=force)
+
+    def _acquire_level_of(
+        self, holder: int, mode: Mode, timeout: float, *, blocking: bool, cancel_check: Callable[[], bool]
+    ) -> AcquireReturnProxy:
+        # Records the level under *holder* instead of the calling thread: an async wrapper's executor thread does not
+        # identify the tasks it holds for. Gives up with Timeout once *cancel_check* is true.
+        return self._acquire(mode, timeout, blocking=blocking, holder=holder, cancel_check=cancel_check)
+
+    def _release_level_of(self, holder: int) -> None:
+        self._release(holder, force=False)
+
+    def _holds_level_of(self, holder: int) -> bool:
+        # Read without the internal lock: an async wrapper asks from its event loop, which must not wait out a release
+        # running on another thread.
+        return (hold := self._hold) is not None and (holder == hold.write_thread_id or holder in hold.read_depths)
+
+    def _release(self, thread_id: int, *, force: bool) -> None:
+        with self._locks.internal:
+            hold = self._hold
+            if hold is None:
+                if force:
+                    return
+                msg = f"Cannot release a lock on {self.lock_file} (lock id: {id(self)}) that is not held"
+                raise RuntimeError(msg)
+            if force:
+                hold.level = 0
+            else:
+                self._raise_if_not_holder(hold, thread_id)
+                hold.leave_one_level(thread_id)
+            if hold.level > 0:
+                return
+            self._hold = None
+
+        # Stop the heartbeat before leaving, so a late tick cannot re-read a snapshot this participant just left and
+        # report an eviction that was its own release. on_compromise runs on that thread and may be what called here,
+        # in which case there is nothing to join.
+        hold.heartbeat_stop.set()
+        try:
+            if hold.heartbeat_thread is not threading.current_thread():
+                hold.heartbeat_thread.join(timeout=min(self.heartbeat_interval + 1.0, threading.TIMEOUT_MAX))
+        finally:
+            # The hold is already gone from this instance, so a join that raises must not strand its record too.
+            hold.participant.leave()
+
+    def _raise_if_not_holder(self, hold: _Hold, thread_id: int) -> None:
+        # The hold's own heartbeat thread may release it, since on_compromise runs there.
+        if thread_id == hold.heartbeat_thread.ident:
+            return
+        # Another thread's release would leave the generation log under the holder and let a peer in.
+        if hold.mode == "write" and thread_id != hold.write_thread_id:
+            msg = (
+                f"Cannot release write lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {thread_id} while it is held by thread {hold.write_thread_id}"
+            )
+            raise RuntimeError(msg)
+        # Readers share one participant, so a thread that holds no read level would end another's hold.
+        if hold.mode == "read" and thread_id not in hold.read_depths:
+            msg = (
+                f"Cannot release read lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {thread_id}, which does not hold it"
+            )
+            raise RuntimeError(msg)
+
+    def _acquire(
+        self,
+        mode: Mode,
+        timeout: float | None,
+        *,
+        blocking: bool | None,
+        holder: int | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AcquireReturnProxy:
+        if self._creator_pid != os.getpid():  # pragma: forked child
+            msg = f"SoftReadWriteLock on {self.lock_file} was invalidated by fork(); construct a new instance"
+            raise RuntimeError(msg)
+        timeout = self.timeout if timeout is None else timeout
+        blocking = self.blocking if blocking is None else blocking
+        holder = threading.get_ident() if holder is None else holder
+
+        with self._locks.internal:
+            if self._closed:
+                raise self._closed_error()
+            timeout = _resolve_read_write_timeout(timeout, blocking=blocking)
+            if self._hold is not None:
+                return self._validate_reentrant(mode, holder)
+
+        deadline = None if timeout == -1 else time.perf_counter() + timeout
+        if not _acquire_thread_lock(
+            self._locks.transaction,
+            blocking=blocking,
+            timeout=timeout,
+            poll_interval=self.poll_interval,
+            cancel_check=cancel_check,
+        ):
+            raise Timeout(self.lock_file) from None
+        try:
+            return self._do_acquire_inner(mode, deadline, holder, blocking=blocking, cancel_check=cancel_check)
+        finally:
+            self._locks.transaction.release()
+
+    def _closed_error(self) -> RuntimeError:
+        return RuntimeError(f"SoftReadWriteLock on {self.lock_file} has been closed")
+
+    def _do_acquire_inner(
+        self,
+        mode: Mode,
+        deadline: float | None,
+        holder: int,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+    ) -> AcquireReturnProxy:
+        with self._locks.internal:
+            if self._hold is not None:
+                return self._validate_reentrant(mode, holder)
+        participant = Participant(
+            self._files,
+            self._root,
+            mode,
+            stale_threshold=self.stale_threshold,
+            clock=time.monotonic,
+            ledger=self._ledger,
+            log=self._log,
+        )
+        participant.publish()
+        try:
+            self._wait_for(participant.advance, deadline=deadline, blocking=blocking, cancel_check=cancel_check)
+        except BaseException:
+            # A contender that gives up must not stay named in the snapshot: a writer left there would block every
+            # reader until a peer waits out the stale threshold. Its own token is all leave() touches, so it cannot
+            # undo a peer's claim.
+            with suppress(OSError):
+                participant.leave()
+            raise
+        stop_event = threading.Event()
+        hold = _Hold(
+            level=1,
+            mode=mode,
+            write_thread_id=holder if mode == "write" else None,
+            read_depths={holder: 1} if mode == "read" else {},
+            participant=participant,
+            heartbeat_thread=_HeartbeatThread(
+                refresh=lambda: self._refresh(participant, hold),
+                interval=self.heartbeat_interval,
+                stop_event=stop_event,
+                name=f"filelock-heartbeat-{id(self):x}",
+            ),
+            heartbeat_stop=stop_event,
+            last_refresh=time.monotonic(),
+        )
+        # Publish the hold and start its heartbeat under one internal-lock section, so a concurrent release() never
+        # observes a hold whose thread has not started and joins it. If the OS refuses the thread, clear the hold and
+        # leave: left in place, a peer evicts the unrefreshed record and acquires while this instance still believes it
+        # holds the lock. A close() that landed while this acquire waited gets the same treatment: published, the hold
+        # would keep its heartbeat and its slot on an instance nobody can release through.
+        start_error: BaseException | None = None
+        with self._locks.internal:
+            if self._closed:
+                start_error = self._closed_error()
+            else:
+                self._hold = hold
+                self._compromise = None
+                try:
+                    hold.heartbeat_thread.start()
+                except BaseException as error:  # ruff:ignore[blind-except]  # clear the slot below and re-raise
+                    self._hold = None
+                    start_error = error
+        if start_error is not None:
+            participant.leave()
+            raise start_error
+        return AcquireReturnProxy(lock=self)
+
+    def _validate_reentrant(self, mode: Mode, holder: int) -> AcquireReturnProxy:
+        hold = self._hold
+        assert hold is not None  # ruff:ignore[assert]  # callers dispatch here only inside the self._hold is not None branch
+        if hold.mode != mode:
+            opposite = "write" if mode == "read" else "read"
+            direction = "downgrade" if mode == "read" else "upgrade"
+            msg = (
+                f"Cannot acquire {mode} lock on {self.lock_file} (lock id: {id(self)}): "
+                f"already holding a {opposite} lock ({direction} not allowed)"
+            )
+            raise RuntimeError(msg)
+        if mode == "write" and holder != hold.write_thread_id:
+            msg = (
+                f"Cannot acquire write lock on {self.lock_file} (lock id: {id(self)}) "
+                f"from thread {holder} while it is held by thread {hold.write_thread_id}"
+            )
+            raise RuntimeError(msg)
+        # Publishing a hold clears the loss recorded for the one before, so a loss seen here is this hold's. Its
+        # heartbeat has stopped and a peer may hold the lock, so a new level must not bypass the log.
+        if (compromise := self._compromise) is not None:
+            raise _lost_hold_error(self.lock_file, mode, compromise)
+        if mode == "read":
+            hold.read_depths[holder] = hold.read_depths.get(holder, 0) + 1
+        hold.level += 1
+        return AcquireReturnProxy(lock=self)
+
+    def _wait_for(
+        self,
+        predicate: Callable[[], bool],
+        *,
+        deadline: float | None,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+    ) -> None:
+        while not predicate():
+            # The flag is read without the lock here only to stop waiting early; publishing the hold re-checks it.
+            if self._closed:
+                raise self._closed_error()
+            now = time.perf_counter()
+            if not blocking or (deadline is not None and now >= deadline):
+                raise Timeout(self.lock_file)
+            # An abandoned acquire gives up like a timed-out one, so the caller's rollback withdraws its claim.
+            if cancel_check is not None and cancel_check():
+                raise Timeout(self.lock_file)
+            sleep_for = self.poll_interval
+            if deadline is not None:
+                sleep_for = min(sleep_for, max(deadline - now, 0.0))
+            time.sleep(sleep_for)
+
+    def _refresh(self, participant: Participant, hold: _Hold) -> bool:
+        # The loop ends at the first loss, so the holder hears about it once. A transient filesystem error (ESTALE /
+        # EIO on the NFS-style filesystems this lock targets) is not a loss: retry rather than report a false
+        # compromise. Report the record unrefreshable only once failures have run long enough that a peer could evict
+        # it before the next success would land, a margin before the record actually ages out.
+        try:
+            outcome, error = participant.heartbeat()
+        except Exception as failure:  # ruff:ignore[blind-except]  # the thread would end with the hold still published
+            self._report_compromise(hold, "refresh-failed", failure)
+            return False
+        if outcome == "ok":
+            hold.last_refresh = time.monotonic()
+            return True
+        if outcome == "lost":
+            self._report_compromise(hold, "evicted", None)
+            return False
+        if time.monotonic() - hold.last_refresh >= self.stale_threshold - self.heartbeat_interval:
+            self._report_compromise(hold, "refresh-failed", error)
+            return False
+        return True
+
+    def _report_compromise(self, hold: _Hold, reason: CompromiseReason, error: Exception | None) -> None:
+        # A tick that outlived its release's join must not stamp the old hold's loss onto whatever was acquired since.
+        with self._locks.internal:
+            if self._hold is not hold:
+                return
+            compromise = LeaseCompromise(
+                lock_file=self.lock_file, token=hold.participant.token, reason=reason, error=error
+            )
+            self._compromise = compromise
+        if self._on_compromise is not None:
+            self._on_compromise(compromise)
+
+    def _reset_after_fork_in_child(self) -> None:  # pragma: forked child
+        self._locks = _Locks(internal=threading.Lock(), transaction=threading.Lock())
+        self._hold = None
+
+
+class _HeartbeatThread(threading.Thread):
+    def __init__(
+        self,
+        refresh: Callable[[], bool],
+        interval: float,
+        stop_event: threading.Event,
+        name: str,
+    ) -> None:
+        super().__init__(name=name, daemon=True)
+        self._refresh = refresh
+        self._interval = interval
+        self._stop_event = stop_event
+
+    def run(self) -> None:
+        # Set on every exit, an on_compromise that raises included, so nothing waits on a thread that is gone.
+        try:
+            while not self._stop_event.wait(self._interval):
+                if not self._refresh():
+                    return
+        finally:
+            self._stop_event.set()
+
+
+def _lost_hold_error(lock_file: str, mode: Mode, compromise: LeaseCompromise) -> RuntimeError:
+    return RuntimeError(
+        f"Cannot acquire {mode} lock on {lock_file}: the current hold was lost ({compromise.reason}), "
+        "release it before acquiring again"
+    )
+
+
+def _validate_intervals(
+    heartbeat_interval: float, stale_threshold: float | None, poll_interval: float
+) -> tuple[float, float, float]:
+    heartbeat_interval = _seconds("heartbeat_interval", heartbeat_interval)
+    if not isfinite(heartbeat_interval) or heartbeat_interval <= 0:
+        msg = f"heartbeat_interval must be positive and finite, got {heartbeat_interval}"
+        raise ValueError(msg)
+    # The heartbeat thread waits this long between refreshes, and Event.wait overflows past TIMEOUT_MAX.
+    _check_timeout_max("heartbeat_interval", heartbeat_interval)
+    stale_threshold = (
+        heartbeat_interval * 3 if stale_threshold is None else _seconds("stale_threshold", stale_threshold)
+    )
+    if not isfinite(stale_threshold) or stale_threshold <= heartbeat_interval:
+        msg = (
+            f"stale_threshold must exceed heartbeat_interval ({heartbeat_interval}) "
+            f"and be finite, got {stale_threshold}"
+        )
+        raise ValueError(msg)
+    if not isfinite(poll_interval := _seconds("poll_interval", poll_interval)) or poll_interval <= 0:
+        msg = f"poll_interval must be positive and finite, got {poll_interval}"
+        raise ValueError(msg)
+    _check_timeout_max("poll_interval", poll_interval)
+    # A waiting writer refreshes its record once per poll, so a poll slower than the threshold reads as dead.
+    if poll_interval >= stale_threshold:
+        msg = f"poll_interval must be below stale_threshold ({stale_threshold}), got {poll_interval}"
+        raise ValueError(msg)
+    return heartbeat_interval, stale_threshold, poll_interval
+
+
+@dataclass
+class _Locks:
+    internal: threading.Lock
+    transaction: threading.Lock
+
+
+@dataclass
+class _Hold:
+    """Everything that exists only while a lock is held; ``None`` when the instance has no lock."""
+
+    level: int
+    mode: Mode
+    write_thread_id: int | None
+    #: Read levels per thread, so a thread can give back only the levels it took.
+    read_depths: dict[int, int]
+    participant: Participant
+    heartbeat_thread: _HeartbeatThread
+    heartbeat_stop: threading.Event
+    last_refresh: float
+
+    def leave_one_level(self, thread_id: int) -> None:
+        self.level -= 1
+        if self.mode == "read":
+            # The heartbeat thread holds no level of its own, so its release gives back one of a reader's.
+            owner = thread_id if thread_id in self.read_depths else next(iter(self.read_depths))
+            if depth := self.read_depths.pop(owner) - 1:
+                self.read_depths[owner] = depth
+
+
+def _cleanup_all_instances() -> None:  # pragma: no cover - runs from atexit at interpreter shutdown
+    for instance in list(_ALL_INSTANCES.values()):
+        with suppress(Exception):
+            instance.release(force=True)
+
+
+atexit.register(_cleanup_all_instances)
+_register_fork_class(SoftReadWriteLock)
+
+
+__all__ = [
+    "SoftReadWriteLock",
+    "_lost_hold_error",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_strict.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_strict.py
new file mode 100644
index 0000000000000000000000000000000000000000..14b4a4831a54b8ff1d8efacb7e6954faefdf55d8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_strict.py
@@ -0,0 +1,1243 @@
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "contextlib",
+    "filelock._error",
+    "filelock._identity",
+    "filelock._marker",
+    "filelock._soft",
+    "filelock._util",
+    "functools",
+    "pathlib",
+    "secrets",
+    "tempfile",
+]
+
+import contextlib
+import errno
+import functools
+import os
+import secrets
+import stat
+import sys
+import tempfile
+import time
+from dataclasses import dataclass
+from errno import EACCES, EEXIST, ENOENT, ENOSYS, EPERM, ESTALE, EXDEV
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, Literal, cast
+
+from filelock._api import BaseFileLock, ThreadLocalFileContext, _canonical, _raise_cleanup_errors
+from filelock._error import SoftFileLockProtocolError
+from filelock._identity import host_name, owner_is_stale, process_start_token
+from filelock._marker import parse_marker
+from filelock._soft import MALFORMED_LOCK_AGE_THRESHOLD, _parse_lock_holder
+from filelock._soft_protocol import STRICT_SOFT_SENTINEL_RECORD
+from filelock._util import foreign_directory_owner, write_all
+
+if sys.platform == "win32":  # pragma: win32 cover
+    from filelock._windows import _is_unlinked, _open_deletable_for_reading, _pin_directory, _unpin_directory
+
+if TYPE_CHECKING:
+    from collections.abc import Callable, Iterator
+
+StrictSoftFileClaimState = Literal["intent", "held"]
+_OccupantState = Literal["sentinel", "held", "exited", "damaged", "unparsable"]
+
+_CLAIM_STATES: Final[frozenset[str]] = frozenset({"intent", "held"})
+_COORDINATION_SUFFIX: Final[str] = ".filelock"
+_CLAIM_DIRECTORY_NAME: Final[str] = "claims"
+_CLAIM_MAGIC: Final[str] = "filelock-strict-v1"
+_CLAIM_RECORD_LIMIT: Final[int] = 1024
+_CLAIM_NAME_PART_COUNT: Final[int] = 3
+_TOKEN_HEX_LENGTH: Final[int] = 32
+_PRIVATE_RECORD_MARKER: Final[str] = ".private-v1-"
+_PRIVATE_RECORD_SUFFIX: Final[str] = ".tmp"
+_PRIVATE_RECORD_RANDOM_HEX_LENGTH: Final[int] = 32
+_PRIVATE_RECORD_GRACE: Final[float] = 2.0
+_UNLINK_MAX_RETRIES: Final[int] = 10
+#: How long a scan waits out a claim held in Windows' delete-pending state before treating it as unreadable.
+_CLAIM_READ_GRACE: Final[float] = 0.5
+_CLAIM_READ_RETRY: Final[float] = 0.002
+#: Rides out a peer replacing the lock path mid-inspection; a foreign node or unreadable record outlasting it is damage.
+_SENTINEL_READ_GRACE: Final[float] = 0.5
+_NODE_DESCRIPTIONS: Final[dict[int, str]] = {stat.S_IFDIR: "a directory", stat.S_IFLNK: "a symlink"}
+#: Windows opens descriptors in text mode by default, which rewrites newlines and truncates a record at a control byte.
+#: The claim and sentinel records are exact binary, so every record descriptor must be binary; POSIX ignores the flag.
+_O_BINARY: Final[int] = getattr(os, "O_BINARY", 0)
+_LEGACY_SENTINEL: Final[bytes] = STRICT_SOFT_SENTINEL_RECORD.encode()
+_WINDOWS_HARD_LINK_UNSUPPORTED: Final[frozenset[int]] = frozenset({1, 17, 50})
+
+# Termux/Android CPython ships without os.link (bionic long had only linkat), so the strict backend's whole hard-link
+# mechanism is absent there. Probe once and gate every os.link reference on it, so importing filelock still works and
+# only an actual StrictSoftFileLock acquire reports the missing capability.
+_HAS_LINK: Final[bool] = hasattr(os, "link")
+
+# Probe dir_fd capability once at import. A per-call ``os.unlink in os.supports_dir_fd`` check flips to False the moment
+# a test mocks os.unlink, silently diverting the code to a different branch than the one under test.
+_OPEN_SUPPORTS_DIR_FD: Final[bool] = os.open in os.supports_dir_fd
+_UNLINK_SUPPORTS_DIR_FD: Final[bool] = os.unlink in os.supports_dir_fd
+_STAT_SUPPORTS_DIR_FD: Final[bool] = os.stat in os.supports_dir_fd
+_LINK_SUPPORTS_DIR_FD: Final[bool] = _HAS_LINK and os.link in os.supports_dir_fd
+_MKDIR_SUPPORTS_DIR_FD: Final[bool] = os.mkdir in os.supports_dir_fd
+_SCANDIR_SUPPORTS_FD: Final[bool] = os.scandir in os.supports_fd
+
+
+def _probe_link_follow_symlinks() -> bool:
+    # os.supports_follow_symlinks lists os.link on PyPy, but its linkat then rejects follow_symlinks=False with EINVAL,
+    # and Windows raises NotImplementedError for the option outright. Link a throwaway file for real so the answer
+    # reflects the runtime rather than its advertisement, and treat any failure as "not honored": the option only
+    # hardens a source this process created with O_EXCL, so skipping it is safe, and a real environment fault surfaces
+    # when the actual link runs.
+    if not _HAS_LINK:
+        return False
+    try:
+        with tempfile.TemporaryDirectory() as directory:
+            source = Path(directory, "probe-source")
+            source.touch()
+            os.link(source, Path(directory, "probe-link"), follow_symlinks=False)
+    except (OSError, NotImplementedError, ValueError):
+        return False
+    return True
+
+
+_LINK_HONORS_FOLLOW_SYMLINKS: Final[bool] = _probe_link_follow_symlinks()
+
+
+def _probe_hard_link_unsupported_errnos() -> frozenset[int]:
+    # GraalPy's errno omits ENOTSUP, so importing the name outright breaks every runtime that ships without it. ENOTSUP
+    # wins wherever it exists, leaving every runtime that names it unchanged. EOPNOTSUPP only stands in for the ones
+    # that do not, and it approximates rather than matches: the two codes agree on Linux but differ on macOS/BSD and on
+    # Windows. Where neither exists a runtime that cannot name "operation not supported" cannot raise it either, and
+    # ENOSYS/EXDEV still classify the link failures it can raise.
+    not_supported = getattr(errno, "ENOTSUP", getattr(errno, "EOPNOTSUPP", None))
+    return frozenset({ENOSYS, EXDEV} if not_supported is None else {ENOSYS, EXDEV, not_supported})
+
+
+_HARD_LINK_UNSUPPORTED_ERRNOS: Final[frozenset[int]] = _probe_hard_link_unsupported_errnos()
+
+
+class StrictSoftFileLock(BaseFileLock):
+    """Portable fail-closed lock based on immutable owner claims."""
+
+    _preserve_lock_file_supported: bool = True
+    _on_acquired_supported: bool = False
+    #: Age cannot clear a strict claim: expiring one on a clock is the overlap the fail-closed contract exists to rule
+    #: out, so only force_break() removes it.
+    _lifetime_supported: bool = False
+    _lifetime_unsupported_reason: str = "a strict claim is never broken by age, only by force_break()"
+    #: Contending processes each publish and rescan several files, so jitter their retries. Seconds. Only a
+    #: poll_interval below this cap jitters; the default equals it and keeps a fixed cadence.
+    _poll_backoff_cap: float = 0.05
+    _occupant_seen: tuple[tuple[float, int, int], float] | None = None
+    #: Set by the finalizer, after which no retry of a failed cleanup can run.
+    _finalizing: bool = False
+
+    def _acquire(self) -> None:
+        # Finish a doorway whose claim cleanup failed before publishing, so this owner never contends with leftovers.
+        self._discard_pending_doorways(exited_only=True)
+        lock_path = Path(self._lock_path)
+        coordination_directory = Path(f"{lock_path}{_COORDINATION_SUFFIX}")
+        claim_directory = coordination_directory / _CLAIM_DIRECTORY_NAME
+        # A process that can write these directories can remove claims from them, so they take the lock's mode plus
+        # search permission where the mode grants read.
+        directory_mode: Final = (mode := self._open_mode()) | (mode & 0o444) >> 2
+        _ensure_protocol_directory(self.lock_file, coordination_directory, directory_mode)
+        _ensure_claim_directory(self.lock_file, claim_directory, directory_mode)
+        if (
+            sentinel_fd := _open_or_create_sentinel(
+                self.lock_file, lock_path, self._open_mode(), self._occupant_unchanged_for
+            )
+        ) is None:
+            return
+        try:
+            sentinel_identity = _file_identity(os.fstat(sentinel_fd))
+        except BaseException as inspection_error:  # preserve inspection and descriptor cleanup errors
+            try:
+                os.close(sentinel_fd)
+            except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve inspection and descriptor cleanup errors
+                _raise_cleanup_errors("strict sentinel inspection cleanup failed", inspection_error, close_error)
+            raise
+        self._mark_descriptor_pending(sentinel_fd, sentinel_identity)
+        try:
+            if won := self._attempt_doorway(claim_directory):
+                self._mark_descriptor_owned(sentinel_fd, sentinel_identity)
+        except BaseException:
+            # Once recorded as held, the acquire's rollback releases the claim instead.
+            if not self.is_locked:
+                self._discard_doorway()
+            raise
+        if not won:
+            self._discard_doorway()
+
+    def _discard_pending_doorways(self, *, exited_only: bool) -> None:
+        if self._context.owner_claim_paths and not self.is_locked:
+            self._discard_doorway()
+        if not isinstance(context := self._context, ThreadLocalFileContext):
+            return
+        # Only this registry reaches an exited thread's thread-local doorway; a live thread finishes its own.
+        own: Final = context.current
+        with self._transition_lock:
+            for pending, thread in self._thread_pending.copy().values():
+                if exited_only and thread.is_alive():
+                    continue
+                context.current = pending
+                try:
+                    self._discard_doorway()
+                finally:
+                    context.current = own
+
+    def _occupant_unchanged_for(self, occupant: os.stat_result) -> float:
+        # SoftFileLock's marker rule: the mtime is only tested for change, timed on this process's monotonic clock.
+        key, now = (occupant.st_mtime, occupant.st_ino, occupant.st_size), time.monotonic()
+        if (seen := self._occupant_seen) is None or seen[0] != key:
+            self._occupant_seen = key, now
+            return 0.0
+        return now - seen[1]
+
+    def _attempt_doorway(self, claim_directory: Path) -> bool:
+        if _read_existing_claims(self.lock_file, claim_directory):
+            return False
+
+        token = secrets.token_hex(_TOKEN_HEX_LENGTH // 2)
+        intent_name = _claim_name("intent", token)
+        intent_path = str(claim_directory / intent_name)
+        # Record each claim before its link: once the link may have committed, any later failure must leave the name for
+        # _discard_doorway. The token makes the name unique, so removing it when the link never happened is a no-op.
+        self._context.owner_claim_paths = (intent_path,)
+        try:
+            with _pin_claim_directory(claim_directory):
+                publication_cleanup_error = _publish_record(
+                    intent_path, _claim_record(token), self._open_mode(), _open_claim_directory
+                )
+        except _PrivateRecordReclaimedError:
+            return False
+        except (NotImplementedError, OSError) as error:
+            _raise_if_hard_links_unsupported(self.lock_file, error)
+            if isinstance(error, OSError) and error.errno == EEXIST:
+                # Another file holds the name, so it is not this owner's to remove.
+                self._context.owner_claim_paths = ()
+                return False
+            raise
+        if publication_cleanup_error is not None:  # pragma: needs dir-fd
+            raise publication_cleanup_error
+
+        claims = _read_existing_claims(self.lock_file, claim_directory)
+        if (
+            not claims
+            or any(claim.state == "held" for claim in claims)
+            or min(claim.name for claim in claims) != intent_name
+        ):
+            return False
+
+        held_name = _claim_name("held", token)
+        held_path = str(claim_directory / held_name)
+        self._context.owner_claim_paths = (held_path, intent_path)
+        try:
+            link_cleanup_error = _link_no_replace(claim_directory, intent_name, held_name)
+        except (NotImplementedError, OSError) as error:
+            _raise_if_hard_links_unsupported(self.lock_file, error)
+            if isinstance(error, OSError) and error.errno == EEXIST:
+                self._context.owner_claim_paths = (intent_path,)
+            raise
+        if link_cleanup_error is not None:  # pragma: needs dir-fd
+            raise link_cleanup_error
+
+        claims = _read_existing_claims(self.lock_file, claim_directory)
+        # Keep the intent claim for the whole hold rather than unlinking it now. The intent has existed, unchanged,
+        # since this owner published it, so a contender's os.scandir is guaranteed to return it (POSIX only leaves the
+        # visibility of entries created or removed *during* a scan unspecified). The freshly linked held claim carries
+        # no such guarantee: a scan that races its creation can miss it. Were the intent removed here, that scan could
+        # observe neither claim and let a larger-token contender win over this owner. The stable intent is the witness
+        # that keeps the phase-five min-token decision computed over the true set. Release unlinks both.
+        return {intent_name, held_name}.issubset(claim.name for claim in claims) and min(
+            _claim_token_key(claim.name) for claim in claims
+        ) == f"v1-{token}.claim"
+
+    @property
+    def claims(self) -> tuple[StrictSoftFileClaim, ...]:
+        """Published claims that block acquisition."""
+        # An inspection writes nothing, so it trusts no record's age rather than probe the filesystem clock.
+        return _read_existing_claims(self.lock_file, self._claim_directory, probe_clock=False)
+
+    @property
+    def lock_path_occupant(self) -> str | None:
+        """
+        What sits at the lock path in place of the strict sentinel, or ``None`` when the sentinel or nothing is there.
+
+        A soft-lock owner's marker blocks acquisition without appearing in :attr:`~filelock.StrictSoftFileLock.claims`;
+        this describes it, naming the PID and host when the marker records them. A directory, a symlink, a marker whose
+        owner on this host has exited, or a file it cannot parse that stays unchanged for two seconds makes acquisition
+        raise :class:`~filelock.SoftFileLockProtocolError` instead and needs an operator to remove it.
+        """
+        try:
+            fd, _, occupant = _inspect_lock_path(Path(_canonical(self.lock_file)))
+        except FileNotFoundError:
+            return None
+        if fd is None:
+            return occupant
+        os.close(fd)
+        return None
+
+    def force_break(self, claim_name: str) -> None:
+        """Remove one named claim, allowing overlap if its owner still holds the protected resource."""
+        _validate_force_break_name(claim_name)
+        with _pin_claim_directory(directory := self._claim_directory):
+            _require_exact_name(directory, claim_name)
+            cleanup_error = _unlink_in_directory(directory, claim_name)
+        if cleanup_error is not None:  # pragma: needs dir-fd
+            raise cleanup_error
+
+    def _release_abandoned_holds(self) -> None:
+        self._finalizing = True
+        super()._release_abandoned_holds()
+        # release() skips a doorway whose cleanup failed, as it is no hold, so a dropped instance would strand claims.
+        with contextlib.suppress(Exception):
+            # GraalPy defers finalizers to the host collector, so its tests cannot drive this cleanup.
+            self._discard_pending_doorways(exited_only=False)  # pragma: needs collected-finalization
+
+    def _reconcile_failed_acquire(self, canonical: str) -> None:
+        # The acquisition is over, so the next one resolves the working directory again rather than reuse this one's.
+        self._context.claim_root = None
+        super()._reconcile_failed_acquire(canonical)
+
+    def _release(self) -> None:
+        fd = cast("int", self._context.lock_file_fd)
+        self._context.claim_root = None
+        remaining, errors = self._unlink_owner_claims()
+        if remaining:
+            _raise_recorded_errors("strict claim release failed", errors)
+        self._mark_descriptor_released()
+        try:
+            self._close_released_fd(fd, default_suppresses=False)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve claim and sentinel cleanup errors
+            errors.append(close_error)
+        if errors:
+            _raise_recorded_errors("strict release cleanup failed", errors)
+
+    def _discard_doorway(self) -> None:
+        remaining, errors = self._unlink_owner_claims()
+        # The pending descriptor holds no lock and a retry needs the claim paths alone. A dropped instance does not
+        # retry, so close it now.
+        if (fd := self._context.pending_lock_file_fd) is not None:
+            self._context.pending_lock_file_fd = self._context.pending_lock_file_fd_identity = None
+            try:
+                self._close_released_fd(fd, default_suppresses=False)
+            except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve claim and sentinel cleanup errors
+                errors.append(close_error)
+        if remaining:
+            # Stay pending, not owned: is_locked reports only a held claim that passed the final rescan. The next
+            # acquire retries this cleanup.
+            _raise_recorded_errors("strict doorway claim cleanup failed", errors)
+        self._mark_descriptor_released()
+        if errors:
+            _raise_recorded_errors("strict doorway cleanup failed", errors)
+
+    def _unlink_owner_claims(self) -> tuple[list[str], list[BaseException]]:
+        remaining, errors = _unlink_owner_paths(self._context.owner_claim_paths)
+        self._context.owner_claim_paths = tuple(remaining)
+        if self._finalizing:
+            # No retry runs after the finalizer and no caller sees its errors, so report success and let it close the
+            # descriptor even when claims remain.
+            return [], []  # pragma: needs collected-finalization
+        return remaining, errors
+
+    @property
+    def _claim_directory(self) -> Path:
+        if self._context.owner_claim_paths:
+            return Path(self._context.owner_claim_paths[0]).parent
+        return Path(f"{_canonical(self.lock_file)}{_COORDINATION_SUFFIX}") / _CLAIM_DIRECTORY_NAME
+
+
+@dataclass(frozen=True)
+class StrictSoftFileClaim:
+    """One parsed strict soft-lock claim."""
+
+    name: str
+    state: StrictSoftFileClaimState
+    token: str
+    pid: int
+    hostname: str
+    #: The owner's process start token, or ``None`` when the platform exposes no proven start time. A strict lock never
+    #: reclaims a claim on its own, so this identifies the owner for tooling rather than driving any automatic break.
+    start: int | None = None
+
+
+class _PrivateRecordReclaimedError(Exception):
+    pass
+
+
+def _open_or_create_sentinel(
+    lock_file: str, path: Path, mode: int, unchanged_for: Callable[[os.stat_result], float]
+) -> int | None:
+    try:
+        return _open_sentinel(lock_file, path, unchanged_for)
+    except FileNotFoundError:
+        pass
+
+    _reclaim_sentinel_private_records(lock_file, path)
+    try:
+        publication_cleanup_error = _publish_record(os.fspath(path), _LEGACY_SENTINEL, mode)
+    except _PrivateRecordReclaimedError:
+        return None
+    except (NotImplementedError, OSError) as error:
+        _raise_if_hard_links_unsupported(lock_file, error)
+        if not isinstance(error, OSError) or error.errno != EEXIST:
+            raise
+    else:
+        if publication_cleanup_error is not None:  # pragma: needs dir-fd
+            raise publication_cleanup_error
+    try:
+        return _open_sentinel(lock_file, path, unchanged_for)
+    except FileNotFoundError:
+        return None
+
+
+def _open_sentinel(lock_file: str, path: Path, unchanged_for: Callable[[os.stat_result], float]) -> int | None:
+    # A live soft-lock owner blocks like any holder. Anything else raises: claims cannot show it and force_break()
+    # cannot remove it, so waiting would wedge every strict contender with no diagnostic. A file no lock parses may be a
+    # soft lock between its create and its write, so it raises only once unchanged as long as a soft contender waits.
+    deadline: float | None = None
+    while True:
+        fd, state, occupant = _inspect_lock_path(path)
+        if fd is not None or state == "held":
+            return fd
+        reason = f"expected the strict sentinel at the lock path, found {occupant}"
+        if state == "unparsable":
+            if unchanged_for(path.lstat()) < MALFORMED_LOCK_AGE_THRESHOLD:
+                return None
+            raise SoftFileLockProtocolError(
+                lock_file, None, f"{reason}, unchanged for {MALFORMED_LOCK_AGE_THRESHOLD:g} seconds"
+            )
+        if deadline is None:
+            deadline = time.monotonic() + _SENTINEL_READ_GRACE
+        if state == "exited" or time.monotonic() >= deadline:
+            raise SoftFileLockProtocolError(lock_file, None, reason)
+        time.sleep(_CLAIM_READ_RETRY)
+
+
+def _inspect_lock_path(path: Path) -> tuple[int | None, _OccupantState, str]:
+    # "held" may be a soft-lock owner that still runs, "exited" is one this host proves gone, "unparsable" is content no
+    # lock parses, and "damaged" is a node no lock writes.
+    if not stat.S_ISREG(mode := path.lstat().st_mode):
+        return None, "damaged", _NODE_DESCRIPTIONS.get(stat.S_IFMT(mode), "a special file")
+    try:
+        fd, record = _open_record((os.fspath(path.parent), None), path.name, _CLAIM_RECORD_LIMIT)
+    except FileNotFoundError:
+        raise
+    except PermissionError as error:
+        # Windows denies the read while a legacy holder keeps its marker open, and a holder running as another user
+        # may leave it unreadable here, so a marker that cannot be read may still be held.
+        return None, "held", f"a file it cannot read ({error.strerror or error})"
+    except OSError as error:
+        return None, "damaged", f"a file it cannot read ({error.strerror or error})"
+    if record == _LEGACY_SENTINEL:
+        return fd, "sentinel", "the strict sentinel"
+    os.close(fd)
+    return None, *_describe_soft_marker(record.decode("utf-8", errors="replace"))
+
+
+def _describe_soft_marker(content: str) -> tuple[_OccupantState, str]:
+    # A SoftFileLock, MarkerSoftFileLock or SoftFileLease owner holds the path legitimately until it releases, so its
+    # marker is contention. One this host proves gone is named, never removed: strict never acts on an inferred death.
+    if (record := parse_marker(content)) is not None:
+        pid, hostname, start = record.pid, record.hostname, record.start
+    elif (holder := _parse_lock_holder(content)) is not None:
+        pid, hostname, start = holder
+    else:
+        return "unparsable", "a file that is neither the sentinel nor a soft-lock marker it can parse"
+    if owner_is_stale(pid, hostname, start):
+        return "exited", f"a soft-lock marker left by pid {pid} on {hostname}, which has exited"
+    return "held", f"a soft-lock marker held by pid {pid} on {hostname}"
+
+
+def _read_claims(
+    lock_file: str, directory_ref: tuple[str, int | None], *, probe_clock: bool
+) -> tuple[StrictSoftFileClaim, ...]:
+    names: Final = _list_claim_names(lock_file, directory_ref, probe_clock=probe_clock)
+    name_parts: dict[str, tuple[StrictSoftFileClaimState, str]] = {}
+    for name in names:
+        if (parts := _parse_claim_name(name)) is None:
+            raise SoftFileLockProtocolError(lock_file, name, "unknown claim name or protocol version")
+        name_parts[name] = parts
+    records: Final = _read_claim_records(lock_file, directory_ref, names, probe_clock=probe_clock)
+    return tuple(_parse_claim(lock_file, name, name_parts[name], records[name]) for name in names if name in records)
+
+
+def _list_claim_names(lock_file: str, directory_ref: tuple[str, int | None], *, probe_clock: bool) -> list[str]:
+    try:
+        with _scandir_relative(directory_ref) as entries:
+            return _public_claim_names(directory_ref, entries, probe_clock=probe_clock)
+    except OSError as error:
+        reason = f"cannot list claim directory: {error.strerror or type(error).__name__}"
+        raise SoftFileLockProtocolError(lock_file, None, reason) from error
+
+
+def _read_claim_records(
+    lock_file: str, directory_ref: tuple[str, int | None], names: list[str], *, probe_clock: bool
+) -> dict[str, bytes]:
+    # A contended scan can list a claim that is not yet cleanly readable, in two ways that both resolve on a brief
+    # retry. Windows fails an open with EACCES while a peer's unlink holds the claim; once the deletion is pending,
+    # _attempt_claim_read skips the claim outright, as another process's handle can keep the name listed for seconds.
+    # On NFS, a peer that unlinks its own claim leaves this client's cached filehandle stale, so the next open returns
+    # ESTALE rather than a clean ENOENT until the lookup revalidates against the server. Retrying re-runs the path
+    # lookup, which turns the vanished claim into ENOENT (skip) or reads it if it still exists. A genuinely unreadable
+    # record (a locked-down file, an EIO fault) still fails closed. The grace starts at the first pending result rather
+    # than before the first attempt, so a slow first read cannot use up the window and leave no retry. One deadline
+    # covers the scan: a deadline per claim let claims that clear one after another stretch a scan, and the caller's
+    # timeout with it, by a grace each.
+    records: dict[str, bytes] = {}
+    deadline: float | None = None
+    while True:
+        pending: dict[str, OSError] = {}
+        for name in names:
+            record, error = _attempt_claim_read(lock_file, directory_ref, name)
+            if error is not None:
+                pending[name] = error
+            elif record is not None:
+                records[name] = record
+        if not pending:
+            return records
+        if deadline is None:
+            deadline = time.monotonic() + _CLAIM_READ_GRACE
+        elif time.monotonic() >= deadline:
+            break
+        names = list(pending)
+        time.sleep(_CLAIM_READ_RETRY)
+    # A stale handle that outlives revalidation is a claim the server no longer has (RFC 1813 NFS3ERR_STALE): skip it
+    # like ENOENT. Skipping a vanished claim overcounts contention at worst; it cannot free a held lock.
+    if denied := [name for name, error in pending.items() if error.errno != ESTALE]:
+        # Windows can deny opens after a peer removes the claim from the directory.
+        listed: Final = set(_list_claim_names(lock_file, directory_ref, probe_clock=probe_clock))
+        if still_listed := [name for name in denied if name in listed]:
+            error = pending[still_listed[0]]
+            reason = f"cannot read claim: {error.strerror or str(error) or type(error).__name__}"
+            raise SoftFileLockProtocolError(lock_file, still_listed[0], reason) from error
+    return records
+
+
+def _attempt_claim_read(
+    lock_file: str, directory_ref: tuple[str, int | None], name: str
+) -> tuple[bytes | None, OSError | None]:
+    # Return the record, or (None, None) when the claim has already gone, or (None, error) for an open the caller may
+    # retry: a Windows EACCES while a peer's unlink holds the claim, or an NFS ESTALE from a peer unlinking its own
+    # claim out from under this client's cached filehandle. Any other OSError is a real fault and fails closed.
+    try:
+        return _read_record(directory_ref, name, _CLAIM_RECORD_LIMIT), None
+    except FileNotFoundError:
+        return None, None
+    except PermissionError as error:
+        if sys.platform == "win32" and _is_unlinked(str(Path(directory_ref[0], name))):  # pragma: win32 cover
+            return None, None
+        return None, error
+    except OSError as error:
+        if error.errno == ESTALE:
+            return None, error
+        reason = f"cannot read claim: {error.strerror or str(error) or type(error).__name__}"
+        raise SoftFileLockProtocolError(lock_file, name, reason) from error
+
+
+def _public_claim_names(
+    directory_ref: tuple[str, int | None], entries: Iterator[os.DirEntry[str]], *, probe_clock: bool
+) -> list[str]:
+    names: list[str] = []
+    now: Callable[[], float | None] = (
+        functools.cache(
+            functools.partial(
+                _filesystem_now, directory_ref, _claim_name("held", secrets.token_hex(_TOKEN_HEX_LENGTH // 2))
+            )
+        )
+        if probe_clock
+        else lambda: None
+    )
+    for entry in entries:
+        if not entry.name.startswith("."):
+            names.append(entry.name)
+        elif (public_name := _private_public_name(entry.name)) is not None and _parse_claim_name(
+            public_name
+        ) is not None:
+            _reclaim_private_record(directory_ref, entry.name, now)
+    return sorted(names)
+
+
+def _read_existing_claims(
+    lock_file: str, directory: Path, *, probe_clock: bool = True
+) -> tuple[StrictSoftFileClaim, ...]:
+    if not _OPEN_SUPPORTS_DIR_FD:  # pragma: lacks dir-fd
+        try:
+            pinned = _pin_claim_directory(directory)
+        except FileNotFoundError:
+            return ()
+        except OSError as error:
+            reason = f"cannot open claim directory: {error.strerror or type(error).__name__}"
+            raise SoftFileLockProtocolError(lock_file, None, reason) from error
+        with pinned:
+            return _read_claims(lock_file, (os.fspath(directory), None), probe_clock=probe_clock)
+    return _read_claims_through_descriptor(lock_file, directory, probe_clock=probe_clock)  # pragma: needs dir-fd
+
+
+def _read_claims_through_descriptor(  # pragma: needs dir-fd
+    lock_file: str, directory: Path, *, probe_clock: bool
+) -> tuple[StrictSoftFileClaim, ...]:
+    try:
+        directory_fd = _open_claim_directory(os.fspath(directory))
+    except FileNotFoundError:
+        return ()
+    except OSError as error:
+        reason = f"cannot open claim directory: {error.strerror or type(error).__name__}"
+        raise SoftFileLockProtocolError(lock_file, None, reason) from error
+    try:
+        return _read_claims(lock_file, (os.fspath(directory), directory_fd), probe_clock=probe_clock)
+    finally:
+        # The scan wrote nothing through the descriptor, so a failed close has no result to report.
+        with contextlib.suppress(OSError):
+            os.close(directory_fd)
+
+
+def _parse_claim(
+    lock_file: str,
+    name: str,
+    name_parts: tuple[StrictSoftFileClaimState, str],
+    record: bytes,
+) -> StrictSoftFileClaim:
+    try:
+        magic, token, pid_text, hostname_hex, start_text, trailing = record.decode("ascii").split("\n")
+        pid = int(pid_text)
+        start = int(start_text) if start_text else None
+        hostname = bytes.fromhex(hostname_hex).decode("utf-8")
+    except (UnicodeDecodeError, ValueError) as error:
+        raise SoftFileLockProtocolError(lock_file, name, "malformed claim record") from error
+    if not all((
+        not trailing,
+        magic == _CLAIM_MAGIC,
+        token == name_parts[1],
+        1 <= pid <= 2**31 - 1,
+        str(pid) == pid_text,
+        start is None or (start >= 0 and str(start) == start_text),
+        hostname.encode().hex() == hostname_hex
+        and hostname.isprintable()
+        and not any(character.isspace() for character in hostname),
+    )):
+        raise SoftFileLockProtocolError(lock_file, name, "malformed claim record")
+    return StrictSoftFileClaim(name=name, state=name_parts[0], token=token, pid=pid, hostname=hostname, start=start)
+
+
+def _parse_claim_name(name: str) -> tuple[StrictSoftFileClaimState, str] | None:
+    if not name.endswith(".claim"):
+        return None
+    parts = name.removesuffix(".claim").split("-")
+    if len(parts) != _CLAIM_NAME_PART_COUNT or parts[0] not in _CLAIM_STATES or parts[1] != "v1":
+        return None
+    token = parts[2]
+    if len(token) != _TOKEN_HEX_LENGTH or any(character not in "0123456789abcdef" for character in token):
+        return None
+    return cast("StrictSoftFileClaimState", parts[0]), token
+
+
+def _claim_name(state: StrictSoftFileClaimState, token: str) -> str:
+    return f"{state}-v1-{token}.claim"
+
+
+def _claim_token_key(name: str) -> str:
+    return name.removeprefix("held-").removeprefix("intent-")
+
+
+def _claim_record(token: str) -> bytes:
+    hostname_hex = host_name().encode().hex()
+    start = process_start_token(os.getpid())
+    start_text = "" if start is None else str(start)
+    return f"{_CLAIM_MAGIC}\n{token}\n{os.getpid()}\n{hostname_hex}\n{start_text}\n".encode("ascii")
+
+
+def _publish_record(
+    public_path: str,
+    record: bytes,
+    mode: int,
+    open_directory: Callable[[str], int] | None = None,
+) -> BaseException | None:
+    directory, public_name = os.path.split(public_path)
+    directory = directory or os.curdir
+    private_name = _private_record_name(public_name)
+    directory_fd = (open_directory or _open_directory)(directory) if _OPEN_SUPPORTS_DIR_FD else None
+    directory_ref = directory, directory_fd
+    try:
+        _publish_record_in_directory(directory_ref, (private_name, public_name), mode, record)
+    except BaseException as publication_error:  # preserve publication and directory cleanup errors
+        try:
+            if directory_fd is not None:  # pragma: needs dir-fd
+                os.close(directory_fd)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # pragma: needs dir-fd  # preserve publication and directory cleanup errors
+            _raise_cleanup_errors("strict publication directory cleanup failed", publication_error, close_error)
+        raise
+    if directory_fd is not None:  # pragma: needs dir-fd
+        try:
+            os.close(directory_fd)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # a claim's caller recorded its path before publishing
+            return close_error
+    return None
+
+
+def _publish_record_in_directory(
+    directory_ref: tuple[str, int | None],
+    names: tuple[str, str],
+    mode: int,
+    record: bytes,
+) -> None:
+    flags = os.O_RDWR | os.O_CREAT | os.O_EXCL | _O_BINARY
+    if (o_nofollow := getattr(os, "O_NOFOLLOW", None)) is not None:  # pragma: needs o-nofollow
+        flags |= o_nofollow
+    private_fd = _open_relative(directory_ref, names[0], flags, mode)
+    private_identity: tuple[int, int] | None = None
+    try:
+        private_identity = _file_identity(os.fstat(private_fd))
+        write_all(private_fd, record)
+        _link_private_record(directory_ref, names, private_identity)
+    except BaseException as publication_error:  # preserve publication and cleanup errors
+        close_error, unlink_error = _close_and_unlink_private_record(
+            directory_ref,
+            names[0],
+            private_fd,
+            private_identity,
+        )
+        if close_error is not None or unlink_error is not None:
+            _raise_cleanup_errors(
+                "strict record publication cleanup failed",
+                publication_error,
+                close_error,
+                unlink_error,
+            )
+        raise
+    close_error, unlink_error = _close_and_unlink_private_record(
+        directory_ref,
+        names[0],
+        private_fd,
+        private_identity,
+    )
+    if close_error is not None or unlink_error is not None:
+        _raise_record_finalization_errors(close_error, unlink_error)
+
+
+def _close_and_unlink_private_record(
+    directory_ref: tuple[str, int | None],
+    private_name: str,
+    private_fd: int,
+    private_identity: tuple[int, int] | None,
+) -> tuple[BaseException | None, BaseException | None]:
+    close_error: BaseException | None = None
+    try:
+        os.close(private_fd)
+    except BaseException as error:  # ruff:ignore[blind-except]  # returned for grouping with unlink failures
+        close_error = error
+    unlink_error: BaseException | None = None
+    try:
+        if private_identity is None:
+            _unlink_relative(directory_ref, private_name)
+        else:
+            _unlink_relative_if_identity(directory_ref, private_name, private_identity)
+    except FileNotFoundError:
+        pass
+    except BaseException as error:  # ruff:ignore[blind-except]  # returned for grouping with close failures
+        unlink_error = error
+    return close_error, unlink_error
+
+
+def _link_private_record(
+    directory_ref: tuple[str, int | None],
+    names: tuple[str, str],
+    private_identity: tuple[int, int],
+) -> None:
+    try:
+        _link_or_find_committed(directory_ref, *names, private_identity)
+    except FileNotFoundError as error:
+        if _relative_identity(directory_ref, names[0]) is not None:
+            raise
+        msg = "private publication record was reclaimed"
+        raise _PrivateRecordReclaimedError(msg) from error
+    if _relative_identity(directory_ref, names[1]) == private_identity:
+        return
+    msg_0 = "private publication record was replaced"
+    raise _PrivateRecordReclaimedError(msg_0)
+
+
+def _raise_record_finalization_errors(
+    close_error: BaseException | None,
+    unlink_error: BaseException | None,
+) -> None:
+    errors = [error for error in (close_error, unlink_error) if error is not None]
+    if len(errors) > 1:
+        _raise_cleanup_errors("strict record finalization failed", errors[0], *errors[1:])
+    raise errors[0]
+
+
+def _private_record_name(public_name: str) -> str:
+    return f".{public_name}{_PRIVATE_RECORD_MARKER}{secrets.token_hex(_PRIVATE_RECORD_RANDOM_HEX_LENGTH // 2)}.tmp"
+
+
+def _private_public_name(private_name: str) -> str | None:
+    if not private_name.startswith(".") or not private_name.endswith(_PRIVATE_RECORD_SUFFIX):
+        return None
+    public_name, marker, random_hex = private_name[1 : -len(_PRIVATE_RECORD_SUFFIX)].rpartition(_PRIVATE_RECORD_MARKER)
+    if (
+        marker != _PRIVATE_RECORD_MARKER
+        or len(random_hex) != _PRIVATE_RECORD_RANDOM_HEX_LENGTH
+        or any(character not in "0123456789abcdef" for character in random_hex)
+    ):
+        return None
+    return public_name
+
+
+def _reclaim_sentinel_private_records(lock_file: str, path: Path) -> None:
+    directory_ref = os.fspath(path.parent), None
+    now = functools.cache(functools.partial(_filesystem_now, directory_ref, path.name))
+    try:
+        with os.scandir(path.parent) as entries:
+            for entry in entries:
+                if _private_public_name(entry.name) == path.name:
+                    _reclaim_private_record(directory_ref, entry.name, now)
+    except OSError as error:
+        reason = f"cannot reclaim sentinel private records: {error.strerror or error}"
+        raise SoftFileLockProtocolError(lock_file, None, reason) from error
+
+
+def _reclaim_private_record(
+    directory_ref: tuple[str, int | None], private_name: str, now: Callable[[], float | None]
+) -> None:
+    directory, directory_fd = directory_ref
+    try:
+        private_stat = (
+            os.stat(private_name, dir_fd=directory_fd, follow_symlinks=False)
+            if directory_fd is not None and _STAT_SUPPORTS_DIR_FD
+            else Path(directory, private_name).lstat()
+        )
+    except FileNotFoundError:
+        return
+    if not stat.S_ISREG(private_stat.st_mode):
+        msg = f"{Path(directory, private_name)} is not a regular private record"
+        raise OSError(msg)
+    if private_stat.st_nlink == 1 and (
+        (current := now()) is None or current - private_stat.st_mtime < _PRIVATE_RECORD_GRACE
+    ):
+        return
+    try:
+        _unlink_private_record_once(directory_ref, private_name)
+    except FileNotFoundError:
+        pass
+    except OSError as error:
+        if error.errno not in {EACCES, EPERM}:
+            raise
+
+
+def _filesystem_now(directory_ref: tuple[str, int | None], public_name: str) -> float | None:
+    # A network filesystem stamps mtimes with the server's clock, which can run seconds off this client's, so read "now"
+    # as the mtime of a probe written like a record (liblockfile uses a read's atime). The probe has a private-record
+    # name, so a scan reaps one left behind. Without a stamp no age is trusted.
+    probe = _private_record_name(public_name)
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | _O_BINARY | getattr(os, "O_NOFOLLOW", 0)
+    try:
+        fd = _open_relative(directory_ref, probe, flags, 0o600)
+    except OSError:
+        return None
+    try:
+        write_all(fd, b"\n")
+        return os.fstat(fd).st_mtime
+    except OSError:
+        return None
+    finally:
+        with contextlib.suppress(OSError):
+            os.close(fd)
+        with contextlib.suppress(OSError):
+            _unlink_private_record_once(directory_ref, probe)
+
+
+def _unlink_private_record_once(directory_ref: tuple[str, int | None], private_name: str) -> None:
+    directory, directory_fd = directory_ref
+    if directory_fd is not None and _UNLINK_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        os.unlink(private_name, dir_fd=directory_fd)
+    else:
+        Path(directory, private_name).unlink()
+
+
+def _relative_identity(directory_ref: tuple[str, int | None], name: str) -> tuple[int, int] | None:
+    directory, directory_fd = directory_ref
+    try:
+        if directory_fd is not None and _STAT_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+            path_stat = os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+        else:  # pragma: win32 cover
+            path_stat = Path(directory, name).lstat()
+    except FileNotFoundError:
+        return None
+    return _file_identity(path_stat)
+
+
+def _unlink_relative_if_identity(
+    directory_ref: tuple[str, int | None],
+    name: str,
+    identity: tuple[int, int],
+) -> None:
+    if _relative_identity(directory_ref, name) == identity:
+        with contextlib.suppress(FileNotFoundError):
+            _unlink_relative(directory_ref, name)
+
+
+def _open_relative(directory_ref: tuple[str, int | None], name: str, flags: int, mode: int) -> int:
+    directory, directory_fd = directory_ref
+    return (
+        os.open(name, flags, mode, dir_fd=directory_fd)
+        if directory_fd is not None
+        else os.open(Path(directory, name), flags, mode)
+    )
+
+
+def _link_relative(directory_ref: tuple[str, int | None], source_name: str, destination_name: str) -> None:
+    directory, directory_fd = directory_ref
+    if directory_fd is not None and _LINK_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        _link_no_follow(source_name, destination_name, src_dir_fd=directory_fd, dst_dir_fd=directory_fd)
+        return
+    _link_no_follow(Path(directory, source_name), Path(directory, destination_name))  # pragma: win32 cover
+
+
+def _link_or_find_committed(
+    directory_ref: tuple[str, int | None],
+    source_name: str,
+    destination_name: str,
+    source_identity: tuple[int, int] | None = None,
+) -> None:
+    try:
+        _link_relative(directory_ref, source_name, destination_name)
+    except FileExistsError:
+        # NFS retransmits a LINK whose reply was lost and reports EEXIST for the committed link; as in open(2) NOTES
+        # and liblockfile, it succeeded when the destination names the source. Prefer the fstat-ed identity: a peer's
+        # scan reaps a private record once it has two links, so its name may already resolve to nothing.
+        if (identity := _relative_identity(directory_ref, destination_name)) is None or identity != (
+            source_identity or _relative_identity(directory_ref, source_name)
+        ):
+            raise
+
+
+def _link_no_follow(
+    source: str | Path,
+    destination: str | Path,
+    *,
+    src_dir_fd: int | None = None,
+    dst_dir_fd: int | None = None,
+) -> None:
+    if not _HAS_LINK:
+        # No os.link at all (Termux/Android): report it as unsupported like a filesystem that refuses hard links, so
+        # the acquire path raises SoftFileLockProtocolError instead of a bare AttributeError.
+        msg = "os.link is unavailable on this platform"
+        raise NotImplementedError(msg)
+    # The source is a private record this process created with O_CREAT | O_EXCL, so follow_symlinks guards nothing an
+    # attacker can reach. Pass the option only when the runtime honors it: PyPy advertises it through
+    # os.supports_follow_symlinks yet its linkat rejects it with EINVAL, so probe once rather than trust the set.
+    if _LINK_HONORS_FOLLOW_SYMLINKS:
+        os.link(source, destination, src_dir_fd=src_dir_fd, dst_dir_fd=dst_dir_fd, follow_symlinks=False)
+    else:  # pragma: lacks link-follow-symlinks
+        os.link(source, destination, src_dir_fd=src_dir_fd, dst_dir_fd=dst_dir_fd)
+
+
+def _unlink_relative(directory_ref: tuple[str, int | None], name: str) -> None:
+    directory, directory_fd = directory_ref
+    if directory_fd is not None and _UNLINK_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        os.unlink(name, dir_fd=directory_fd)
+    elif sys.platform == "win32":  # pragma: win32 cover
+        _unlink_in_directory(Path(directory), name)
+    else:
+        Path(directory, name).unlink()  # pragma: win32 no cover
+
+
+def _link_no_replace(directory: Path, source_name: str, destination_name: str) -> BaseException | None:
+    if _LINK_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        directory_fd = _open_claim_directory(str(directory))
+        try:
+            _link_or_find_committed((str(directory), directory_fd), source_name, destination_name)
+        except BaseException as link_error:  # preserve link and directory cleanup errors
+            try:
+                os.close(directory_fd)
+            except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve link and directory cleanup errors
+                _raise_cleanup_errors("strict link directory cleanup failed", link_error, close_error)
+            raise
+        try:
+            os.close(directory_fd)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # the caller recorded the held path before linking
+            return close_error
+        return None
+    with _pin_claim_directory(directory):  # pragma: win32 cover
+        _link_or_find_committed((str(directory), None), source_name, destination_name)
+    return None  # pragma: win32 cover
+
+
+def _unlink_owner_path(path: str) -> BaseException | None:
+    directory, name = os.path.split(path)
+    with _pin_claim_directory(claim_directory := Path(directory or os.curdir)):
+        return _unlink_in_directory(claim_directory, name)
+
+
+def _unlink_owner_paths(paths: tuple[str, ...]) -> tuple[list[str], list[BaseException]]:
+    results = [(path, _unlink_owner_path_result(path)) for path in paths]
+    return [path for path, (removed, _) in results if not removed], [
+        error for _, (_, error) in results if error is not None
+    ]
+
+
+def _unlink_owner_path_result(path: str) -> tuple[bool, BaseException | None]:
+    try:
+        cleanup_error = _unlink_owner_path(path)
+    except FileNotFoundError:
+        return True, None
+    except BaseException as error:  # ruff:ignore[blind-except]  # keep ownership when unlink did not commit
+        return False, error
+    return True, cleanup_error
+
+
+def _raise_recorded_errors(message: str, errors: list[BaseException]) -> None:
+    if len(errors) > 1:
+        _raise_cleanup_errors(message, errors[0], *errors[1:])
+    raise errors[0]
+
+
+def _unlink_in_directory(directory: Path, name: str) -> BaseException | None:
+    if _UNLINK_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        directory_fd = _open_claim_directory(str(directory))
+        try:
+            os.unlink(name, dir_fd=directory_fd)
+        except BaseException as unlink_error:  # preserve unlink and directory cleanup errors
+            try:
+                os.close(directory_fd)
+            except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve unlink and directory cleanup errors
+                _raise_cleanup_errors("strict unlink directory cleanup failed", unlink_error, close_error)
+            raise
+        try:
+            os.close(directory_fd)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # caller commits the removed path before raising
+            return close_error
+        return None
+    if sys.platform != "win32":  # pragma: win32 no cover
+        Path(directory / name).unlink()
+        return None
+    retry_delay = 0.001  # pragma: win32 cover
+    for attempt in range(_UNLINK_MAX_RETRIES):  # pragma: win32 cover
+        if (error := _unlink_error(directory / name)) is None:
+            return None
+        if error.errno not in {EACCES, EPERM} or attempt == _UNLINK_MAX_RETRIES - 1:
+            raise error
+        time.sleep(retry_delay)
+        retry_delay *= 2
+    return None  # pragma: no cover  # the final retry returns or raises
+
+
+def _unlink_error(path: Path) -> OSError | None:  # pragma: win32 cover
+    try:
+        path.unlink()
+    except OSError as error:
+        return error
+    return None
+
+
+def _pin_claim_directory(directory: Path) -> contextlib.ExitStack[bool | None]:
+    return _pin_directories(directory.parent, directory)
+
+
+def _pin_directories(*directories: Path) -> contextlib.ExitStack[bool | None]:
+    # Windows has no dir_fd, so each operation resolves every path component by name again. An open handle on a
+    # directory blocks a rename of it, and with it a swap for a junction (a directory that points at another directory),
+    # until the operation ends. Other platforms work through descriptors and hold nothing.
+    stack: contextlib.ExitStack[bool | None] = contextlib.ExitStack()
+    if sys.platform == "win32":  # pragma: win32 cover
+        with stack:
+            for directory in directories:
+                stack.callback(_unpin_directory, _pin_directory(str(directory)))
+            return stack.pop_all()
+    return stack  # pragma: win32 no cover
+
+
+def _open_directory(directory: str, dir_fd: int | None = None) -> int:  # pragma: needs dir-fd
+    return os.open(directory, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | getattr(os, "O_NOFOLLOW", 0), dir_fd=dir_fd)
+
+
+def _open_claim_directory(directory: str) -> int:  # pragma: needs dir-fd
+    # O_NOFOLLOW applies to the last path component. A process that can rename entries in the lock's directory can
+    # swap the coordination directory for a symlink after any check of its name, so open the claim directory relative
+    # to a descriptor of the coordination directory: a symlink at either level then fails the open.
+    coordination_directory, name = os.path.split(directory)
+    coordination_fd = _open_directory(coordination_directory)
+    try:
+        return _open_directory(name, coordination_fd)
+    finally:
+        # The walk wrote nothing through it, and an error here would leak the descriptor this function returns.
+        with contextlib.suppress(OSError):
+            os.close(coordination_fd)
+
+
+def _scandir_relative(
+    directory_ref: tuple[str, int | None],
+) -> contextlib.AbstractContextManager[Iterator[os.DirEntry[str]]]:
+    directory, directory_fd = directory_ref
+    if directory_fd is not None and _SCANDIR_SUPPORTS_FD:  # pragma: needs dir-fd
+        return os.scandir(directory_fd)
+    return os.scandir(directory)  # pragma: lacks dir-fd
+
+
+def _lstat_relative(directory_ref: tuple[str, int | None], name: str) -> os.stat_result:
+    directory, directory_fd = directory_ref
+    if directory_fd is not None and _STAT_SUPPORTS_DIR_FD:  # pragma: needs dir-fd
+        return os.stat(name, dir_fd=directory_fd, follow_symlinks=False)
+    return Path(directory, name).lstat()
+
+
+def _read_record(directory_ref: tuple[str, int | None], name: str, limit: int) -> bytes:
+    fd, record = _open_record(directory_ref, name, limit, deletable=True)
+    os.close(fd)
+    return record
+
+
+def _open_record(
+    directory_ref: tuple[str, int | None], name: str, limit: int, *, deletable: bool = False
+) -> tuple[int, bytes]:
+    path = Path(directory_ref[0], name)
+    path_stat = _lstat_relative(directory_ref, name)
+    if not stat.S_ISREG(path_stat.st_mode):
+        msg = f"{path} is not a regular file"
+        raise OSError(msg)
+    if deletable and sys.platform == "win32":  # pragma: win32 cover
+        # A claim's owner must be able to unlink it while another process reads it. The sentinel stays for the lock's
+        # lifetime, so it keeps os.open.
+        fd = _open_deletable_for_reading(str(path))
+    else:
+        flags = os.O_RDONLY | _O_BINARY | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_NONBLOCK", 0)
+        fd = _open_relative(directory_ref, name, flags, 0)
+    try:
+        record = _read_opened_record(fd, path, path_stat, limit)
+    except BaseException as read_error:  # preserve read and descriptor cleanup errors
+        try:
+            os.close(fd)
+        except BaseException as close_error:  # ruff:ignore[blind-except]  # preserve read and descriptor cleanup errors
+            _raise_cleanup_errors("strict record read cleanup failed", read_error, close_error)
+        raise
+    return fd, record
+
+
+def _read_opened_record(fd: int, path: Path, path_stat: os.stat_result, limit: int) -> bytes:
+    opened_stat = os.fstat(fd)
+    if not stat.S_ISREG(opened_stat.st_mode):
+        msg = f"{path} is not a regular file"
+        raise OSError(msg)
+    if _file_identity(opened_stat) != _file_identity(path_stat):
+        msg = f"{path} changed while opening"
+        raise OSError(msg)
+    record = os.read(fd, limit + 1)
+    if len(record) > limit:
+        msg = f"{path} exceeds {limit} bytes"
+        raise OSError(msg)
+    return record
+
+
+def _ensure_claim_directory(lock_file: str, directory: Path, mode: int) -> None:
+    if not (_OPEN_SUPPORTS_DIR_FD and _MKDIR_SUPPORTS_DIR_FD):  # pragma: lacks dir-fd
+        try:
+            pinned = _pin_directories(directory.parent)
+        except OSError as error:
+            raise SoftFileLockProtocolError(lock_file, None, f"cannot open {directory.parent}") from error
+        with pinned:
+            _ensure_protocol_directory(lock_file, directory, mode)
+    else:  # pragma: needs dir-fd
+        # mkdir follows a symlink in every component but the last, so create against a descriptor of the real parent.
+        try:
+            coordination_fd = _open_directory(os.fspath(directory.parent))
+        except OSError as error:
+            raise SoftFileLockProtocolError(lock_file, None, f"cannot open {directory.parent}") from error
+        try:
+            _ensure_protocol_directory(lock_file, directory, mode, coordination_fd)
+        finally:
+            with contextlib.suppress(OSError):
+                os.close(coordination_fd)
+
+
+def _ensure_protocol_directory(lock_file: str, directory: Path, mode: int, parent_fd: int | None = None) -> None:
+    try:
+        if parent_fd is None:
+            directory.mkdir(mode)
+        else:  # pragma: needs dir-fd
+            os.mkdir(directory.name, mode, dir_fd=parent_fd)
+    except FileExistsError:
+        try:
+            found = _lstat_relative((os.fspath(directory.parent), parent_fd), directory.name)
+            owner = foreign_directory_owner(
+                found, directory.parent.stat() if parent_fd is None else os.fstat(parent_fd)
+            )
+        except OSError as error:
+            raise SoftFileLockProtocolError(lock_file, None, f"cannot inspect {directory}") from error
+        if (
+            not stat.S_ISDIR(found.st_mode)
+            or getattr(found, "st_file_attributes", 0) & stat.FILE_ATTRIBUTE_REPARSE_POINT
+        ):
+            raise SoftFileLockProtocolError(lock_file, None, f"{directory} is not a real directory") from None
+        if owner is not None:  # pragma: needs foreign-sticky-tmp
+            reason = f"{directory} belongs to uid {owner}, not to this process's account or the parent's owner"
+            raise SoftFileLockProtocolError(lock_file, None, reason) from None
+    _settle_directory_mode(lock_file, directory, mode, parent_fd)
+
+
+def _settle_directory_mode(lock_file: str, directory: Path, mode: int, parent_fd: int | None) -> None:
+    # The umask or a default ACL can leave the directory wider than the mode, now or in an earlier release, so narrow a
+    # directory this account owns to the mode. The sticky bit (a directory flag that lets only a file's owner remove it)
+    # then protects each claim from other accounts even where the mode admits them. Windows has neither mode bits nor a
+    # sticky bit.
+    if sys.platform != "win32":  # pragma: win32 no cover
+        try:
+            fd = os.open(
+                directory.name if parent_fd is not None else os.fspath(directory),
+                os.O_RDONLY | getattr(os, "O_DIRECTORY", 0) | getattr(os, "O_NOFOLLOW", 0),
+                dir_fd=parent_fd,
+            )
+        except OSError as error:
+            raise SoftFileLockProtocolError(lock_file, None, f"cannot open {directory}") from error
+        try:
+            found = os.fstat(fd)
+            settled = found.st_mode & 0o7000 | found.st_mode & mode & 0o777 | stat.S_ISVTX
+            if found.st_uid == os.geteuid() and settled != stat.S_IMODE(found.st_mode):
+                os.fchmod(fd, settled)
+        except OSError as error:
+            raise SoftFileLockProtocolError(lock_file, None, f"cannot set the mode of {directory}") from error
+        finally:
+            os.close(fd)
+
+
+def _validate_force_break_name(name: str) -> None:
+    invalid_component = not name or name.startswith(".") or name in {os.curdir, os.pardir}
+    if invalid_component or any(separator in name for separator in ("/", "\\", "\x00")):
+        msg = "claim_name must be one public claim basename"
+        raise ValueError(msg)
+
+
+def _require_exact_name(directory: Path, name: str) -> None:
+    directory_fd = _open_claim_directory(os.fspath(directory)) if _OPEN_SUPPORTS_DIR_FD else None
+    try:
+        with _scandir_relative((os.fspath(directory), directory_fd)) as entries:
+            if not any(entry.name == name for entry in entries):
+                raise FileNotFoundError(ENOENT, os.strerror(ENOENT), name)
+    finally:
+        if directory_fd is not None:  # pragma: needs dir-fd
+            with contextlib.suppress(OSError):
+                os.close(directory_fd)
+
+
+def _raise_if_hard_links_unsupported(lock_file: str, error: NotImplementedError | OSError) -> None:
+    unsupported = (
+        isinstance(error, NotImplementedError)
+        or error.errno in _HARD_LINK_UNSUPPORTED_ERRNOS
+        or (getattr(error, "winerror", None) in _WINDOWS_HARD_LINK_UNSUPPORTED)
+    )
+    if unsupported:
+        reason = "filesystem does not support atomic no-replace hard-link publication"
+        raise SoftFileLockProtocolError(lock_file, None, reason) from error
+
+
+def _file_identity(st: os.stat_result) -> tuple[int, int]:
+    return st.st_dev, st.st_ino
+
+
+__all__ = [
+    "StrictSoftFileClaim",
+    "StrictSoftFileClaimState",
+    "StrictSoftFileLock",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_unix.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_unix.py
new file mode 100644
index 0000000000000000000000000000000000000000..30c627638c5c32ead1977bf381342c5836ead72f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_unix.py
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["contextlib", "filelock._util", "pathlib", "typing", "warnings"]
+
+import os
+import sys
+import warnings
+from contextlib import suppress
+from errno import EACCES, EAGAIN, ENOSYS, EWOULDBLOCK
+from pathlib import Path
+from typing import Final, cast
+
+from filelock._api import BaseFileLock
+from filelock._util import remove_own_file
+
+has_fcntl = False
+if sys.platform == "win32":  # pragma: win32 cover
+
+    class UnixFileLock(BaseFileLock):
+        """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+else:  # pragma: win32 no cover
+    try:
+        import fcntl
+
+        _ = (fcntl.flock, fcntl.LOCK_EX, fcntl.LOCK_NB, fcntl.LOCK_UN)
+    except (ImportError, AttributeError):
+        _FCNTL_UNAVAILABLE: Final[str] = "fcntl is unavailable"
+
+        def _lock_fd_nonblocking(_fd: int) -> bool:
+            raise OSError(ENOSYS, _FCNTL_UNAVAILABLE)
+
+        def _unlock_fd(_fd: int) -> None:
+            raise OSError(ENOSYS, _FCNTL_UNAVAILABLE)
+
+    else:
+        has_fcntl = True
+        # Contention errnos for a nonblocking flock. EAGAIN/EWOULDBLOCK are the usual "held elsewhere" codes; some
+        # filesystems report EACCES instead, so treat it as contention too rather than a permanent error.
+        _CONTENTION_ERRNOS: Final[frozenset[int]] = frozenset({EACCES, EAGAIN, EWOULDBLOCK})
+
+        def _lock_fd_nonblocking(fd: int) -> bool:
+            # One nonblocking exclusive flock attempt shared by UnixFileLock and lock_descriptor, so both contend on
+            # the same lock and classify errors identically. The caller owns fd; this never closes it.
+            try:
+                fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+            except OSError as exception:
+                if exception.errno in _CONTENTION_ERRNOS:
+                    return False
+                raise
+            return True
+
+        def _unlock_fd(fd: int) -> None:
+            fcntl.flock(fd, fcntl.LOCK_UN)
+
+    def _flock_is_missing(fd: int) -> bool:
+        try:
+            _lock_fd_nonblocking(fd)
+        except OSError as exception:
+            return exception.errno == ENOSYS
+        return False  # a flock the probe won is released when the caller closes fd
+
+    class UnixFileLock(BaseFileLock):
+        """
+        Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems.
+
+        We leave the lock file in place after release. Unlinking a locked file on Unix splits
+        waiters across inodes and breaks mutual exclusion for processes that coordinate via the
+        same path.
+        """
+
+        def _acquire(self) -> None:
+            if (missing_flock := self._acquire_native()) is not None:
+                fd, exception, created = missing_flock
+                self._switch_to_soft_lock(fd, exception, created=created)
+
+        def _acquire_native(self) -> tuple[int, OSError, bool] | None:
+            if (opened := self._open_lock_file()) is None:
+                return None
+            fd, created = opened
+            self._mark_descriptor_pending(fd)
+            if created:
+                # Before the flock: a peer may win it first, and only the creator may set the mode. Outside the flock
+                # handler below: an fchmod that answers ENOSYS says nothing about flock.
+                try:
+                    self._apply_explicit_mode(fd)
+                except BaseException:
+                    self._mark_descriptor_released()
+                    os.close(fd)
+                    raise
+            # One guard covers the flock through the recording of the hold. A signal handler that raises in between
+            # would otherwise leave an unreferenced descriptor, and its flock, open until the process exits.
+            locked = False
+            try:
+                locked = _lock_fd_nonblocking(fd)
+                if locked and self._finalize_locked_fd(fd):
+                    return None
+            except BaseException as exception:
+                if not locked and isinstance(exception, OSError) and exception.errno == ENOSYS:
+                    return fd, exception, created
+                # Contention returns False from _lock_fd_nonblocking, so a raise here is a failure.
+                self._mark_descriptor_released()
+                os.close(fd)
+                raise
+            self._mark_descriptor_released()
+            os.close(fd)  # contention or an unlinked inode; let the retry loop try again
+            return None
+
+        def _open_lock_file(self) -> tuple[int, bool] | None:
+            # No O_TRUNC: a contender that loses the flock must not truncate the holder's file (#591), and neither may
+            # the winner, since a file renamed or hard-linked to the lock path is indistinguishable from a lock file.
+            # O_EXCL tells whether this attempt created the inode: only then does it get the explicit mode, and the
+            # ENOSYS fallback removes only its own placeholder. O_NONBLOCK: a lease (Linux F_SETLEASE) on the file would
+            # otherwise block the open for up to fs.lease-break-time, beyond timeout, blocking=False and cancel_check.
+            open_flags = os.O_RDWR | os.O_NONBLOCK
+            if (o_nofollow := getattr(os, "O_NOFOLLOW", None)) is not None:
+                open_flags |= o_nofollow
+            open_mode = self._open_mode()
+            try:
+                return os.open(self._lock_path, open_flags | os.O_CREAT | os.O_EXCL, open_mode), True
+            except FileExistsError:
+                pass
+            except FileNotFoundError:
+                # On FUSE/NFS a split LOOKUP + CREATE lets a concurrent unlink() race the create, so ENOENT is transient
+                # contention. An empty or separator-terminated path (Path() strips the separator) fails this way on
+                # every attempt on macOS, so re-raise rather than retry forever.
+                if self._lock_path and not self._lock_path.endswith(os.sep) and Path(self._lock_path).parent.exists():
+                    return None
+                raise
+            except PermissionError:
+                # Sticky-bit dirs (e.g. /tmp): O_CREAT fails if another user owns the file (#317).
+                if not Path(self._lock_path).exists():
+                    raise
+            return self._open_existing_lock_file(open_flags, open_mode)
+
+        def _open_existing_lock_file(self, open_flags: int, open_mode: int) -> tuple[int, bool] | None:
+            try:
+                return os.open(self._lock_path, open_flags, open_mode), False
+            except FileNotFoundError:
+                return None  # unlinked since the create attempt; let the retry loop start over
+            except BlockingIOError:
+                return None  # a lease is breaking: contention, so the retry loop keeps the deadline
+            except PermissionError:
+                # A marker another account left is readable but not writable. Without flock, waiting on it only needs
+                # reading it; with flock the lock writes its file, so the denial stands.
+                try:
+                    fd = os.open(self.lock_file, open_flags & ~os.O_RDWR | os.O_RDONLY)
+                except (FileNotFoundError, BlockingIOError):
+                    return None  # unlinked, or leased: the kernel checks permission before the lease
+                if _flock_is_missing(fd):
+                    return fd, False
+                os.close(fd)
+                raise
+
+        def _switch_to_soft_lock(self, fd: int, missing_flock: OSError, *, created: bool) -> None:
+            # The filesystem does not implement flock. Fail closed when the caller opted out of existence-lock
+            # semantics (#603), asked to preserve the pathname (#605), or set an on_acquired hook (#607), none of which
+            # a soft lock can honor.
+            falls_back: Final = self._fallback_to_soft and not self._preserve_lock_file and self._on_acquired is None
+            try:
+                # A file this attempt did not create may be a peer's live marker, so it stays. Our own placeholder goes
+                # before the close: the open descriptor keeps its inode number from a peer's marker, and an exchange
+                # puts back a peer's marker that replaced it.
+                if created and falls_back:
+                    with suppress(OSError):
+                        remove_own_file(self._lock_path, fd)
+            finally:
+                self._mark_descriptor_released()
+                os.close(fd)
+            if not falls_back:
+                raise missing_flock
+            self._fallback_to_soft_lock()
+            self._acquire()
+
+        def _finalize_locked_fd(self, fd: int) -> bool:
+            # Runs with the flock held; the caller closes fd on failure. A concurrent _release() may have unlinked
+            # the file between our open() and flock(), which st_nlink 0 shows. That lock guards no name, so report
+            # it and let the retry loop start over.
+            if (stat_result := os.fstat(fd)).st_nlink == 0:
+                return False
+            self._mark_descriptor_owned(fd, (stat_result.st_dev, stat_result.st_ino))
+            return True
+
+        def _apply_explicit_mode(self, fd: int) -> None:
+            if self.has_explicit_mode:
+                with suppress(PermissionError):
+                    os.fchmod(fd, self._context.mode)
+
+        def _fallback_to_soft_lock(self: BaseFileLock) -> None:
+            # Import lazily: this runs only on the rare flock fallback, and asyncio imports _unix, so a
+            # module-level import of it here would cycle.
+            from filelock._soft import SoftFileLock  # ruff:ignore[import-outside-top-level]
+
+            warnings.warn("flock not supported on this filesystem, falling back to SoftFileLock", stacklevel=2)
+            from filelock.asyncio import AsyncSoftFileLock, BaseAsyncFileLock  # ruff:ignore[import-outside-top-level]
+
+            self.__class__ = AsyncSoftFileLock if isinstance(self, BaseAsyncFileLock) else SoftFileLock
+
+        def _release(self) -> None:
+            fd = cast("int", self._context.lock_file_fd)
+            # Retain the descriptor until flock succeeds: a failed unlock leaves the kernel lock held, so is_locked
+            # must keep reporting held for a retry. Once flock commits, clear held state and close as post-unlock
+            # cleanup; a close failure (EIO on FUSE/Docker bind mounts) does not make the kernel lock held again.
+            _unlock_fd(fd)
+            self._mark_descriptor_released()
+            self._close_released_fd(fd, default_suppresses=True)
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+    __all__ = ["UnixFileLock", "has_fcntl"]
+else:  # pragma: win32 no cover
+    __all__ = ["UnixFileLock", "_lock_fd_nonblocking", "_unlock_fd", "has_fcntl"]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..8dbdadd74333d6f20c3ea48ebafbfe175ae98b15
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_util.py
@@ -0,0 +1,399 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["pathlib", "platform", "secrets"]
+
+import errno
+import os
+import platform
+import secrets
+import stat
+import sys
+from contextlib import contextmanager, suppress
+from errno import EACCES, EINVAL, EIO, EISDIR, ENOSYS, EXDEV
+from functools import cache
+from pathlib import Path
+from typing import TYPE_CHECKING, Final, cast
+
+if TYPE_CHECKING:
+    import ctypes
+    from collections.abc import Callable, Generator
+    from contextlib import AbstractContextManager
+
+
+def write_all(fd: int, data: bytes) -> None:
+    """
+    Write the whole buffer to *fd*, looping over the short writes POSIX lets ``os.write`` make.
+
+    A caller that stopped after one short write would leave a truncated marker behind. A peer that reads between two
+    writes sees a prefix of the record; each caller has to tolerate that. Lock records need not survive a power loss, so
+    we skip ``fsync``.
+
+    :param fd: file descriptor open for writing.
+    :param data: bytes to write in full.
+
+    :raises OSError: if a write reports zero progress before the record is complete.
+
+    """
+    remaining = memoryview(data)
+    while remaining:
+        if (written := os.write(fd, remaining)) == 0:
+            raise OSError(EIO, "os.write wrote 0 bytes before the record was complete")
+        remaining = remaining[written:]
+
+
+def raise_on_not_writable_file(filename: str) -> None:
+    """
+    Raise an exception if attempting to open the file for writing would fail.
+
+    Separates files that can never be written from files that are writable but currently locked.
+
+    :param filename: file to check
+
+    :raises OSError: as if the file was opened for writing.
+
+    """
+    try:
+        # lstat, not stat: settles exists-and-writable in one syscall, and a hostile symlink at the lock path would
+        # make stat inspect the link target, letting an attacker turn a contended acquire into a misleading
+        # PermissionError / IsADirectoryError and probe that target's attributes. The real open passes O_NOFOLLOW and
+        # refuses the symlink anyway.
+        file_stat = os.lstat(filename)
+    except OSError:
+        return  # does not exist, or an error the caller cannot act on
+
+    if stat.S_ISDIR(file_stat.st_mode):
+        if sys.platform == "win32":  # pragma: win32 cover
+            raise PermissionError(EACCES, "Permission denied", filename)
+        raise IsADirectoryError(EISDIR, "Is a directory", filename)  # pragma: win32 no cover
+
+    # No mtime guard: the old `if st_mtime != 0` skip covered NFS/Linux quirks where os.lstat returned an all-zero
+    # struct, which it no longer does. Skipping on mtime 0 let a read-only file or a directory at the lock path pass
+    # as missing, so acquire() blocked forever on an open that cannot succeed.
+    # Match open() credentials where supported; group permissions and ACLs can grant access without S_IWUSR. Do not
+    # follow a symlink, as the lstat above does not: one swapped in since would be judged by its target.
+    if not (file_stat.st_mode & stat.S_IWUSR) and not os.access(
+        filename,
+        os.W_OK,
+        effective_ids=os.access in os.supports_effective_ids,
+        follow_symlinks=os.access not in os.supports_follow_symlinks,
+    ):
+        try:
+            os.lstat(filename)
+        except FileNotFoundError:
+            # A holder may unlink its marker between lstat() and access(); let the caller attempt creation.
+            return
+        raise PermissionError(EACCES, "Permission denied", filename)
+
+
+def ensure_directory_exists(filename: Path | str) -> None:
+    """
+    Ensure the directory containing the file exists (create it if necessary).
+
+    :param filename: file.
+
+    """
+    Path(filename).parent.mkdir(parents=True, exist_ok=True)
+
+
+@contextmanager
+def pin_inode(lock_file: str) -> Generator[int | None]:
+    """
+    Keep the file at *lock_file* allocated for the length of the block and yield its inode number.
+
+    An inode is the kernel's identity for a file, independent of its name, and its number names a file only while the
+    inode stays allocated. ext4 hands a freed number to the next file created. Once a stale marker is unlinked, the next
+    holder's marker can therefore carry the number a contender read a moment ago. A caller that reads the marker inside
+    the block, gives up unless it read the yielded inode, and breaks the marker before leaving can rely on the number.
+
+    :param lock_file: path to the lock file about to be read and perhaps broken.
+
+    :returns: the pinned inode number, or ``None`` where nothing can be pinned. Windows cannot rename a file this
+        process holds open, so it needs no pin. Without ``O_PATH`` a symlink or a socket cannot be opened.
+
+    :raises FileNotFoundError: if the path is gone.
+
+    """
+    if sys.platform == "win32":  # pragma: win32 cover
+        yield None
+    else:  # pragma: win32 no cover
+        # O_PATH pins any node, a symlink or socket included, without read permission and without the filesystem seeing
+        # an open; elsewhere a nonblocking read-only open pins what it can.
+        flags: Final = getattr(os, "O_PATH", os.O_RDONLY | getattr(os, "O_NONBLOCK", 0)) | getattr(os, "O_NOFOLLOW", 0)
+        try:
+            fd = os.open(lock_file, flags)
+        except FileNotFoundError:
+            raise
+        except OSError:
+            yield None
+            return
+        try:
+            yield os.fstat(fd).st_ino
+        finally:
+            os.close(fd)
+
+
+def remove_own_file(lock_file: str, fd: int) -> None:  # pragma: win32 no cover
+    """
+    Remove *lock_file* while it still names the file open as *fd*; the caller closes the descriptor afterwards.
+
+    Where the platform has an atomic exchange, a stale break takes the file through it, so a peer's marker found at the
+    path goes back. Otherwise the path is unlinked by name if it still names this file. The open descriptor keeps the
+    inode allocated, so a matching number cannot belong to a successor's marker.
+
+    :raises OSError: if the descriptor cannot be read or the unlink fails.
+
+    """
+    own: Final = os.fstat(fd)
+    with suppress(FileNotFoundError):
+        break_lock_file(lock_file, own.st_mtime, own.st_ino)
+        if os.path.samestat(os.lstat(lock_file), own):
+            Path(lock_file).unlink()
+
+
+def foreign_directory_owner(directory: os.stat_result, parent: os.stat_result) -> int | None:
+    """
+    Return the uid that owns *directory* when another account controls it under a sticky parent.
+
+    A lock that keeps its ownership records in a directory relies on them staying in place. The sticky bit (a directory
+    flag that lets only a file's owner remove it) on a parent such as ``/tmp`` stops other accounts from renaming the
+    directory away. A directory that this account or the parent's owner owns is therefore safe there. One that another
+    account owns is outside the lock's control. Without the sticky bit, any process that can create the directory can
+    also rename this account's own one away, so a refusal there would change nothing. Linux applies the same rule for
+    ``fs.protected_regular``.
+
+    :param directory: ``lstat`` of the directory found in place.
+    :param parent: ``stat`` of the directory that holds it.
+
+    :returns: the owning uid when another account controls the directory, otherwise ``None``.
+
+    """
+    if sys.platform != "win32" and parent.st_mode & stat.S_ISVTX:  # pragma: needs foreign-sticky-tmp
+        return None if directory.st_uid in {os.geteuid(), parent.st_uid} else directory.st_uid
+    return None
+
+
+def break_lock_file(lock_file: str, mtime_before: float, ino_before: int) -> None:
+    """
+    Remove the lock file a caller found stale with modification time *mtime_before* and inode *ino_before*.
+
+    The caller keeps the judged file open until we return, through :func:`pin_inode` or its own descriptor, so no
+    other file can carry *ino_before* meanwhile. Right before breaking we ``lstat`` the lock again and leave it alone
+    if a peer recreated it since the caller judged it stale, as Mercurial re-reads a lock under its break lock.
+
+    On Linux (``renameat2``) and macOS (``renamex_np``) the platform can exchange two names in one step. There we swap
+    the marker with a placeholder of our own, so the lock path never stands empty, and a contender that polls meanwhile
+    finds a file it cannot parse and waits. If the file we took is not the one judged stale, a peer recreated the lock,
+    and a second exchange puts it back. Otherwise we remove it and then our placeholder. Of several processes racing to
+    break the same lock, only one takes the stale file.
+
+    Windows cannot exchange names, but it refuses to rename a marker its live holder keeps open. There we rename the
+    marker aside and, if it was recreated after all, link it back. ``link`` never replaces a name, so a marker a third
+    process created meanwhile keeps the path. Elsewhere without an exchange (NFS, SMB and other filesystems that refuse
+    it, platforms without the call) a rename would leave the path empty beside a possibly live holder. We then do not
+    move the marker, and the caller waits for ``timeout`` or ``break_lock()``.
+
+    We compare inodes as well as modification times, because NFS and FAT store coarse modification times. The times are
+    compared for equality, since a file's owner can set any time. We ``lstat`` so a symlink a peer swaps in is never
+    followed. The break name carries a random token so no other process can guess it.
+
+    :param lock_file: path to the lock file to break.
+    :param mtime_before: modification time the caller saw when it judged the lock stale.
+    :param ino_before: inode number the caller saw when it judged the lock stale.
+
+    :raises OSError: if taking the marker fails, for example because the file vanished, another user owns it in a
+        sticky directory, or on Windows its holder keeps it open.
+
+    """
+    if (current := os.lstat(lock_file)).st_mtime != mtime_before or current.st_ino != ino_before:
+        return
+    break_path: Final[str] = f"{lock_file}.break.{os.getpid()}.{secrets.token_hex(16)}"
+    if exchange_supported():  # pragma: win32 no cover
+        _swap_out(lock_file, break_path, mtime_before, ino_before)
+    elif _MOVES_WITHOUT_EXCHANGE:  # pragma: win32 cover
+        _break_by_rename(lock_file, break_path, mtime_before, ino_before)
+
+
+def _swap_out(lock_file: str, break_path: str, mtime_before: float, ino_before: int) -> None:  # pragma: win32 no cover
+    # An atomic exchange with a placeholder takes the marker without the lock path ever being empty. No contender can
+    # then create a marker while this one is judged, and a live marker goes back the same way.
+    fd: Final = os.open(break_path, os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0), 0o600)
+    try:
+        try:
+            # Not a record any lock writes, so a contender that reads it waits, and one left by a crash ages out. The
+            # PID tells the contender that evicts it whose break names to search for a marker this process left.
+            write_all(fd, f"filelock/break\n{os.getpid()}\n".encode())
+            exchanged = exchange_names(break_path, lock_file)
+        except OSError:
+            exchanged = False
+        if not exchanged:
+            Path(break_path).unlink()
+            return
+        if (grabbed := os.lstat(break_path)).st_mtime == mtime_before and grabbed.st_ino == ino_before:
+            Path(break_path).unlink()
+            # Our descriptor keeps the placeholder's inode allocated, so a matching number at the path is still ours.
+            if os.path.samestat(os.lstat(lock_file), os.fstat(fd)):
+                Path(lock_file).unlink()
+        else:
+            exchange_names(break_path, lock_file)
+            Path(break_path).unlink()
+    finally:
+        os.close(fd)
+
+
+def _break_by_rename(
+    lock_file: str, break_path: str, mtime_before: float, ino_before: int
+) -> None:  # pragma: win32 cover
+    # Renaming the marker aside empties the path until a recreated live marker is put back. link never replaces a name,
+    # so a marker a third process created meanwhile keeps the path, and the live one waits under the break name.
+    # Without os.link, or where the filesystem refuses hard links, the live one waits there too.
+    with _pinned_for_rename(lock_file):
+        Path(lock_file).rename(break_path)
+    if (st_after := os.lstat(break_path)).st_mtime == mtime_before and st_after.st_ino == ino_before:
+        unlink_path(break_path)
+    elif stat.S_ISREG(st_after.st_mode) and hasattr(os, "link"):  # pragma: needs hard-link
+        with suppress(OSError):
+            os.link(break_path, lock_file, follow_symlinks=False)
+            unlink_path(break_path)
+
+
+if sys.platform == "win32":  # pragma: win32 cover
+
+    def _pinned_for_rename(path: str) -> AbstractContextManager[object]:
+        # A rename by path waits on a Level 1 or batch oplock holder until it answers or closes. Opening first with
+        # FILE_COMPLETE_IF_OPLOCKED turns that wait into BlockingIOError, and the open handle shares delete, so the
+        # rename then proceeds. Imported here because _windows imports this module.
+        from filelock._windows import open_for_delete_without_oplock_wait  # ruff:ignore[import-outside-top-level]
+
+        return os.fdopen(open_for_delete_without_oplock_wait(path), "rb")
+
+    def unlink_path(path: str) -> None:
+        from filelock._windows import unlink_without_oplock_wait  # ruff:ignore[import-outside-top-level]
+
+        unlink_without_oplock_wait(path)
+
+else:  # pragma: win32 no cover
+
+    def unlink_path(path: str) -> None:
+        Path(path).unlink()
+
+
+def exchange_supported() -> bool:
+    """Whether this platform has a call that swaps two names in one step; a filesystem may still refuse it."""
+    return _rename_call() is not None
+
+
+def exchange_names(source: str, target: str) -> bool:  # pragma: win32 no cover
+    """
+    Swap the names *source* and *target* in one step, so neither ever stands empty, where :func:`exchange_supported`.
+
+    :returns: ``False`` where the filesystem cannot, so the caller falls back
+
+    :raises OSError: for any other failure, such as a missing name or a denied rename
+
+    """
+    renamer, exchange_flag = cast("tuple[Callable[[bytes, bytes, int], int], int]", _rename_call())
+    if not (error := renamer(os.fsencode(source), os.fsencode(target), exchange_flag)):
+        return True
+    # EXDEV: overlayfs and some FUSE filesystems refuse an exchange between layers.
+    if error in {EINVAL, ENOSYS, EXDEV, getattr(errno, "ENOTSUP", EINVAL), getattr(errno, "EOPNOTSUPP", EINVAL)}:
+        return False
+    raise OSError(error, os.strerror(error), source, None, target)
+
+
+@cache
+def _rename_call() -> tuple[Callable[[bytes, bytes, int], int], int] | None:
+    # The call returns 0 or the errno. Looked up on first use, since most processes never break a lock and ctypes is
+    # slow to import. None where ctypes is missing (GraalPy) or the platform has no exchange.
+    try:
+        import ctypes  # ruff:ignore[import-outside-top-level]  # only a stale break needs it
+    except ImportError:  # pragma: no cover  # GraalPy ships without ctypes
+        return None
+    if sys.platform in {"linux", "android"}:  # pragma: linux cover
+        if (renameat2 := _renameat2(ctypes.CDLL(None, use_errno=True))) is None:
+            return None  # pragma: no cover  # an architecture the CI matrix does not run
+        return renameat2, 2  # RENAME_EXCHANGE in linux/fs.h
+    if sys.platform == "darwin":  # pragma: darwin cover
+        renamex_np: Final = ctypes.CDLL(None, use_errno=True).renamex_np
+        renamex_np.argtypes = [ctypes.c_char_p, ctypes.c_char_p, ctypes.c_uint]
+        renamex_np.restype = ctypes.c_int
+
+        def call_renamex_np(source: bytes, target: bytes, flags: int) -> int:
+            return 0 if renamex_np(source, target, flags) == 0 else ctypes.get_errno()
+
+        return call_renamex_np, 0x2  # RENAME_SWAP in sys/stdio.h
+    return None  # pragma: linux no cover  # pragma: android no cover  # pragma: darwin no cover
+
+
+def _renameat2(libc: ctypes.CDLL) -> Callable[[bytes, bytes, int], int] | None:  # pragma: linux cover
+    # Reached through syscall(2) rather than the C library's wrapper. glibc 2.28, musl 1.2.2 and bionic API 30 added
+    # the wrapper, and Termux ships an older bionic; the kernel has had the call since 3.15. The number is the
+    # architecture's own, so an architecture outside the table gets no exchange rather than another call.
+    import ctypes  # ruff:ignore[import-outside-top-level]  # only a stale break needs it
+
+    numbers: Final = {
+        "x86_64": 316,
+        "i386": 353,
+        "i686": 353,
+        "armv7l": 382,
+        "armv8l": 382,
+        "aarch64": 276,
+        "riscv64": 276,
+        "loongarch64": 276,
+        "ppc64le": 357,
+        "s390x": 347,
+    }
+    if (number := numbers.get(platform.machine())) is None:
+        return None  # pragma: no cover  # an architecture the CI matrix does not run
+    syscall: Final = libc.syscall
+    syscall.restype = ctypes.c_long
+    at_fdcwd: Final = -100
+
+    def call_renameat2(source: bytes, target: bytes, flags: int) -> int:
+        arguments: Final = (
+            ctypes.c_long(number),
+            ctypes.c_int(at_fdcwd),
+            ctypes.c_char_p(source),
+            ctypes.c_int(at_fdcwd),
+            ctypes.c_char_p(target),
+            ctypes.c_uint(flags),
+        )
+        return 0 if syscall(*arguments) == 0 else ctypes.get_errno()
+
+    return call_renameat2
+
+
+def touch(name: str, *, fd: int) -> None:
+    # Prefer the already-open, already-verified fd so a peer that swaps a symlink or a different file in at the
+    # path after our O_NOFOLLOW read cannot redirect the touch: utime then targets the inode behind the fd.
+    # Where the platform cannot utime an fd, fall back to a path-based touch that still refuses to follow a
+    # symlink where supported, matching the O_NOFOLLOW reads used elsewhere here.
+    if _SUPPORTS_UTIME_FD:  # pragma: needs utime-fd
+        os.utime(fd, None)
+        return
+    os.utime(name, None, follow_symlinks=not _SUPPORTS_UTIME_NOFOLLOW)  # pragma: lacks utime-fd
+
+
+# Windows refuses to rename a marker its live holder keeps open, so renaming aside only moves a marker nobody holds.
+# Elsewhere without an exchange a contender could take the emptied path beside a live holder, so the marker stays and
+# the lock counts as held.
+_MOVES_WITHOUT_EXCHANGE: Final[bool] = sys.platform == "win32"
+# Retargeting os.utime to an open fd lets a heartbeat refresh the exact inode it verified instead of whatever the
+# pathname now names.
+_SUPPORTS_UTIME_FD: Final[bool] = sys.platform != "win32" and os.utime in os.supports_fd
+# os.utime follows symlinks unless told not to; not every platform can refuse the follow, so probe support.
+_SUPPORTS_UTIME_NOFOLLOW: Final[bool] = os.utime in os.supports_follow_symlinks
+
+
+__all__ = [
+    "break_lock_file",
+    "ensure_directory_exists",
+    "exchange_names",
+    "exchange_supported",
+    "foreign_directory_owner",
+    "pin_inode",
+    "raise_on_not_writable_file",
+    "remove_own_file",
+    "touch",
+    "unlink_path",
+    "write_all",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_windows.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_windows.py
new file mode 100644
index 0000000000000000000000000000000000000000..0258961a7ec86ae6fd2938890eab949e9a783a6c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/_windows.py
@@ -0,0 +1,780 @@
+from __future__ import annotations
+
+__lazy_modules__ = ["filelock._util", "msvcrt", "struct"]
+
+import os
+import struct
+import sys
+import time
+from contextlib import contextmanager, suppress
+from errno import ENOENT, ENOTDIR, EWOULDBLOCK
+from functools import cache
+from typing import TYPE_CHECKING, Final, cast
+
+from filelock._api import BaseFileLock
+from filelock._util import raise_on_not_writable_file
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+if sys.platform == "win32":  # pragma: win32 cover
+    import ctypes
+    import msvcrt
+    from ctypes import wintypes
+
+    _GENERIC_READ: Final[int] = 0x80000000
+    _GENERIC_WRITE: Final[int] = 0x40000000
+    _SYNCHRONIZE: Final[int] = 0x00100000
+    _DELETE: Final[int] = 0x00010000
+    _DESIRED_ACCESS: Final[int] = _GENERIC_READ | _GENERIC_WRITE | _SYNCHRONIZE
+    _FILE_SHARE_READ_WRITE: Final[int] = (
+        0x00000001 | 0x00000002
+    )  # read | write; matches os.open (_SH_DENYNO), no delete
+    _FILE_OPEN: Final[int] = 1  # open the file only if it exists; the NtCreateFile OPEN_EXISTING
+    _FILE_OPEN_IF: Final[int] = 3  # open the file if it exists, create it otherwise; the NtCreateFile OPEN_ALWAYS
+    # Attribute-only access skips share-mode checks, so the probe sees a name's deletion state rather than a reader.
+    _FILE_READ_ATTRIBUTES: Final[int] = 0x00000080
+    _FILE_SHARE_ALL: Final[int] = 0x00000001 | 0x00000002 | 0x00000004  # read | write | delete
+    _FILE_ATTRIBUTE_READONLY: Final[int] = 0x00000001
+    _FILE_ATTRIBUTE_NORMAL: Final[int] = 0x00000080
+    _FILE_ATTRIBUTE_REPARSE_POINT: Final[int] = 0x00000400
+    # CreateOptions: keep the handle synchronous (the CRT and msvcrt.locking rely on a maintained file position),
+    # refuse a directory, return at once instead of waiting for an oplock holder to answer the break, and open a
+    # reparse point rather than following it so the check below acts on the link itself.
+    _FILE_SYNCHRONOUS_IO_NONALERT: Final[int] = 0x00000020
+    _FILE_NON_DIRECTORY_FILE: Final[int] = 0x00000040
+    _FILE_DELETE_ON_CLOSE: Final[int] = 0x00001000
+    _FILE_COMPLETE_IF_OPLOCKED: Final[int] = 0x00000100
+    _FILE_OPEN_REPARSE_POINT: Final[int] = 0x00200000
+    _CREATE_OPTIONS: Final[int] = (
+        _FILE_SYNCHRONOUS_IO_NONALERT | _FILE_NON_DIRECTORY_FILE | _FILE_COMPLETE_IF_OPLOCKED | _FILE_OPEN_REPARSE_POINT
+    )
+    # Listing access takes part in share-mode checks, unlike attribute-only access, so a handle that holds it without
+    # FILE_SHARE_DELETE blocks renames and removals of the directory until it closes.
+    _FILE_LIST_DIRECTORY: Final[int] = 0x00000001
+    _FILE_DIRECTORY_FILE: Final[int] = 0x00000001
+    _DIRECTORY_OPTIONS: Final[int] = _FILE_SYNCHRONOUS_IO_NONALERT | _FILE_DIRECTORY_FILE | _FILE_OPEN_REPARSE_POINT
+    _OBJ_CASE_INSENSITIVE: Final[int] = 0x00000040  # Win32 name lookups are case-insensitive
+    _OWNER_WRITE: Final[int] = 0o200
+    _GROUP_AND_OTHERS: Final[int] = 0o077
+    # The DACL os.mkdir(mode=0o700) applies, less the inheritance flags a file has no use for: protected, so the
+    # directory's inheritable entries stay out, with full access for SYSTEM, Administrators and the owner.
+    _OWNER_ONLY_SDDL: Final[str] = "D:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;OW)"
+    _SDDL_REVISION_1: Final[int] = 1
+    _INVALID_HANDLE_VALUE: Final[int | None] = ctypes.c_void_p(-1).value
+
+    # LockFileEx locks a byte range at an offset carried in OVERLAPPED, independent of the descriptor's file position.
+    # msvcrt.locking starts at the current position instead, so a metadata write between lock and unlock could shift
+    # the byte a later unlock targets; the explicit offset removes that hazard for both the path lock and #608's
+    # descriptor lock.
+    _LOCKFILE_FAIL_IMMEDIATELY: Final[int] = 0x00000001
+    _LOCKFILE_EXCLUSIVE_LOCK: Final[int] = 0x00000002
+    _ERROR_ACCESS_DENIED: Final[int] = 5
+    _ERROR_LOCK_VIOLATION: Final[int] = 33  # another handle holds the byte range
+    _ERROR_NOT_LOCKED: Final[int] = 158  # the byte range is not locked
+
+    # NtCreateFile returns the raw NTSTATUS as its value, where CreateFileW collapses several of these into one
+    # ERROR_ACCESS_DENIED. Telling them apart is the point (#604): a name pending deletion or a share conflict is
+    # transient and worth a retry, a real access denial is not.
+    _STATUS_SUCCESS: Final[int] = 0x00000000
+    # A success code that comes with a handle: another handle's oplock is breaking and its holder has not answered yet.
+    _STATUS_OPLOCK_BREAK_IN_PROGRESS: Final[int] = 0x00000108
+    _STATUS_ACCESS_DENIED: Final[int] = 0xC0000022
+    _STATUS_OBJECT_NAME_NOT_FOUND: Final[int] = 0xC0000034
+    _STATUS_OBJECT_PATH_NOT_FOUND: Final[int] = 0xC000003A
+    _STATUS_SHARING_VIOLATION: Final[int] = 0xC0000043
+    _STATUS_DELETE_PENDING: Final[int] = 0xC0000056
+    #: Probes, 2 ms apart, for transient STATUS_ACCESS_DENIED while a peer unlinks the name (#604). A count ensures
+    #: every probe runs even when the process stalls; oplock breaks use the caller's wait instead.
+    _ACCESS_DENIED_PROBES: Final[int] = 250
+    _ACCESS_DENIED_GRACE: Final[float] = 0.5
+    _ACCESS_DENIED_RETRY: Final[float] = 0.002
+
+    _ntdll: Final[ctypes.WinDLL] = ctypes.WinDLL("ntdll")
+    _kernel32: Final[ctypes.WinDLL] = ctypes.WinDLL("kernel32", use_last_error=True)
+    _advapi32: Final[ctypes.WinDLL] = ctypes.WinDLL("advapi32", use_last_error=True)
+
+    class _UNICODE_STRING(ctypes.Structure):  # ruff:ignore[invalid-class-name]  # mirrors the Win32 struct name
+        _fields_ = (
+            ("Length", wintypes.USHORT),  # byte length, not character count
+            ("MaximumLength", wintypes.USHORT),
+            ("Buffer", wintypes.LPWSTR),
+        )
+
+    class _OBJECT_ATTRIBUTES(ctypes.Structure):  # ruff:ignore[invalid-class-name]  # mirrors the Win32 struct name
+        _fields_ = (
+            ("Length", wintypes.ULONG),
+            ("RootDirectory", wintypes.HANDLE),
+            ("ObjectName", ctypes.POINTER(_UNICODE_STRING)),
+            ("Attributes", wintypes.ULONG),
+            ("SecurityDescriptor", ctypes.c_void_p),
+            ("SecurityQualityOfService", ctypes.c_void_p),
+        )
+
+    class _IO_STATUS_BLOCK(ctypes.Structure):  # ruff:ignore[invalid-class-name]  # mirrors the Win32 struct name
+        _fields_ = (
+            ("Status", ctypes.c_void_p),  # a union of NTSTATUS and PVOID, so it is pointer-sized
+            ("Information", ctypes.c_void_p),
+        )
+
+    class _SECURITY_ATTRIBUTES(ctypes.Structure):  # ruff:ignore[invalid-class-name]  # mirrors the Win32 struct name
+        _fields_ = (
+            ("nLength", wintypes.DWORD),
+            ("lpSecurityDescriptor", ctypes.c_void_p),
+            ("bInheritHandle", wintypes.BOOL),
+        )
+
+    class _OVERLAPPED(ctypes.Structure):  # mirrors the Win32 struct name
+        _fields_ = (
+            ("Internal", ctypes.c_void_p),  # ULONG_PTR: pointer-sized, not DWORD, or the x64 layout corrupts Offset
+            ("InternalHigh", ctypes.c_void_p),
+            ("Offset", wintypes.DWORD),  # the DUMMYUNIONNAME struct, flattened: low 32 bits of the byte offset
+            ("OffsetHigh", wintypes.DWORD),
+            ("hEvent", wintypes.HANDLE),
+        )
+
+    class _BY_HANDLE_FILE_INFORMATION(ctypes.Structure):  # ruff:ignore[invalid-class-name]  # mirrors the Win32 struct name
+        _fields_ = (
+            ("dwFileAttributes", wintypes.DWORD),
+            ("ftCreationTime", wintypes.FILETIME),
+            ("ftLastAccessTime", wintypes.FILETIME),
+            ("ftLastWriteTime", wintypes.FILETIME),
+            ("dwVolumeSerialNumber", wintypes.DWORD),
+            ("nFileSizeHigh", wintypes.DWORD),
+            ("nFileSizeLow", wintypes.DWORD),
+            ("nNumberOfLinks", wintypes.DWORD),
+            ("nFileIndexHigh", wintypes.DWORD),
+            ("nFileIndexLow", wintypes.DWORD),
+        )
+
+    _ntdll.NtCreateFile.restype = wintypes.LONG  # NTSTATUS
+    _ntdll.NtCreateFile.argtypes = [
+        ctypes.POINTER(wintypes.HANDLE),
+        wintypes.DWORD,
+        ctypes.POINTER(_OBJECT_ATTRIBUTES),
+        ctypes.POINTER(_IO_STATUS_BLOCK),
+        ctypes.POINTER(ctypes.c_longlong),  # PLARGE_INTEGER AllocationSize
+        wintypes.ULONG,
+        wintypes.ULONG,
+        wintypes.ULONG,
+        wintypes.ULONG,
+        ctypes.c_void_p,
+        wintypes.ULONG,
+    ]
+    _ntdll.RtlDosPathNameToNtPathName_U_WithStatus.restype = wintypes.LONG  # NTSTATUS
+    _ntdll.RtlDosPathNameToNtPathName_U_WithStatus.argtypes = [
+        wintypes.LPCWSTR,
+        ctypes.POINTER(_UNICODE_STRING),
+        ctypes.c_void_p,
+        ctypes.c_void_p,
+    ]
+    _ntdll.RtlFreeUnicodeString.restype = None
+    _ntdll.RtlFreeUnicodeString.argtypes = [ctypes.POINTER(_UNICODE_STRING)]
+    _ntdll.RtlNtStatusToDosError.restype = wintypes.ULONG
+    _ntdll.RtlNtStatusToDosError.argtypes = [wintypes.LONG]
+
+    _kernel32.CloseHandle.argtypes = [wintypes.HANDLE]
+    _kernel32.CloseHandle.restype = wintypes.BOOL
+    _kernel32.GetFileInformationByHandle.argtypes = [wintypes.HANDLE, ctypes.POINTER(_BY_HANDLE_FILE_INFORMATION)]
+    _kernel32.GetFileInformationByHandle.restype = wintypes.BOOL
+    _kernel32.LockFileEx.argtypes = [
+        wintypes.HANDLE,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        ctypes.POINTER(_OVERLAPPED),
+    ]
+    _kernel32.LockFileEx.restype = wintypes.BOOL
+    _kernel32.UnlockFileEx.argtypes = [
+        wintypes.HANDLE,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        ctypes.POINTER(_OVERLAPPED),
+    ]
+    _kernel32.UnlockFileEx.restype = wintypes.BOOL
+    _advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW.argtypes = [
+        wintypes.LPCWSTR,
+        wintypes.DWORD,
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.POINTER(wintypes.ULONG),
+    ]
+    _advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW.restype = wintypes.BOOL
+    _advapi32.GetNamedSecurityInfoW.argtypes = [
+        wintypes.LPCWSTR,
+        ctypes.c_int,
+        wintypes.DWORD,
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.POINTER(ctypes.c_void_p),
+        ctypes.POINTER(ctypes.c_void_p),
+    ]
+    _advapi32.GetNamedSecurityInfoW.restype = wintypes.DWORD
+    _advapi32.OpenThreadToken.argtypes = [
+        wintypes.HANDLE,
+        wintypes.DWORD,
+        wintypes.BOOL,
+        ctypes.POINTER(wintypes.HANDLE),
+    ]
+    _advapi32.OpenThreadToken.restype = wintypes.BOOL
+    _advapi32.OpenProcessToken.argtypes = [wintypes.HANDLE, wintypes.DWORD, ctypes.POINTER(wintypes.HANDLE)]
+    _advapi32.OpenProcessToken.restype = wintypes.BOOL
+    _advapi32.GetTokenInformation.argtypes = [
+        wintypes.HANDLE,
+        ctypes.c_int,
+        ctypes.c_void_p,
+        wintypes.DWORD,
+        ctypes.POINTER(wintypes.DWORD),
+    ]
+    _advapi32.GetTokenInformation.restype = wintypes.BOOL
+    _kernel32.GetCurrentProcess.restype = wintypes.HANDLE
+    _kernel32.GetCurrentThread.restype = wintypes.HANDLE
+    _kernel32.LocalFree.argtypes = [ctypes.c_void_p]
+    _kernel32.LocalFree.restype = ctypes.c_void_p
+    _kernel32.CreateDirectoryW.argtypes = [wintypes.LPCWSTR, ctypes.POINTER(_SECURITY_ATTRIBUTES)]
+    _kernel32.CreateDirectoryW.restype = wintypes.BOOL
+    _kernel32.CreateFileW.argtypes = [
+        wintypes.LPCWSTR,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        ctypes.c_void_p,
+        wintypes.DWORD,
+        wintypes.DWORD,
+        wintypes.HANDLE,
+    ]
+    _kernel32.CreateFileW.restype = ctypes.c_void_p
+
+    def _lock_fd_nonblocking(fd: int) -> bool:
+        # One nonblocking exclusive LockFileEx attempt shared by WindowsFileLock and lock_descriptor, over the one-byte
+        # range at offset 0. True on acquisition, False on contention, raise otherwise. The caller owns fd; the handle
+        # from get_osfhandle belongs to the CRT descriptor and must not be closed here.
+        overlapped = _OVERLAPPED()  # zero-initialized, so Offset/OffsetHigh/hEvent are 0
+        flags = _LOCKFILE_EXCLUSIVE_LOCK | _LOCKFILE_FAIL_IMMEDIATELY
+        if _kernel32.LockFileEx(msvcrt.get_osfhandle(fd), flags, 0, 1, 0, ctypes.byref(overlapped)):
+            return True
+        err = ctypes.get_last_error()
+        if err == _ERROR_LOCK_VIOLATION:
+            return False
+        # A non-contention LockFileEx failure is not reproducible in-process.
+        raise ctypes.WinError(err)  # pragma: no cover
+
+    def _unlock_fd(fd: int) -> None:
+        overlapped = _OVERLAPPED()  # the same offset 0 and one-byte length the lock used
+        if (  # pragma: no cover  # only an interrupted earlier release leaves our own range unlocked
+            not _kernel32.UnlockFileEx(msvcrt.get_osfhandle(fd), 0, 1, 0, ctypes.byref(overlapped))
+            and (err := ctypes.get_last_error()) != _ERROR_NOT_LOCKED
+        ):
+            raise ctypes.WinError(err)
+
+    class WindowsFileLock(BaseFileLock):
+        """
+        Uses ``LockFileEx`` to hard lock a byte range of the lock file on Windows systems.
+
+        Lock file cleanup: Windows attempts to delete the lock file after release, but deletion is
+        not guaranteed in multi-threaded scenarios where another thread holds an open handle. The lock
+        file may persist on disk, which does not affect lock correctness.
+        """
+
+        def _acquire(self) -> None:
+            raise_on_not_writable_file(self._lock_path)
+
+            # The reparse test is bound to the opened handle, so a symlink or junction swapped in cannot defeat it
+            # through a check-then-open TOCTOU race.
+            try:
+                fd = _open_non_reparse_fd(self._lock_path, self._open_mode())
+            except BlockingIOError:
+                return  # an oplock holder has not answered its break; let the retry loop keep its deadline
+            if fd is None:
+                return  # open contention (share conflict or a name pending deletion); let the retry loop try again
+            try:
+                locked = _lock_fd_nonblocking(fd)
+                if locked:
+                    self._mark_descriptor_owned(fd)
+            except BaseException:
+                # Closing drops the byte-range lock, so a hold already recorded for this descriptor must go with it.
+                self._mark_descriptor_released()
+                os.close(fd)
+                raise
+            if not locked:
+                os.close(fd)  # another holder owns the byte-range lock; let the retry loop try again
+
+        def _release(self) -> None:
+            fd = cast("int", self._context.lock_file_fd)
+            # Retain the descriptor until the OS unlock succeeds: if UnlockFileEx raises, the byte-range lock is still
+            # held, so is_locked must keep reporting held rather than losing the fd. Only after the unlock commits do
+            # close and unlink run as post-unlock cleanup; their failure cannot make the lock held again.
+            _unlock_fd(fd)
+            self._mark_descriptor_released()
+            self._close_released_fd(fd, default_suppresses=False)
+            if not self._preserve_lock_file:  # preserve_lock_file keeps a stable file identity for the caller (#605)
+                with suppress(OSError):
+                    unlink_without_oplock_wait(self._lock_path)
+
+    def _open_non_reparse_fd(path: str, mode: int, *, oplock_wait: float = _ACCESS_DENIED_GRACE) -> int | None:
+        """
+        Open *path* for locking while refusing reparse points, bound to the handle actually locked.
+
+        The file is opened through ``NtCreateFile`` with ``FILE_OPEN_REPARSE_POINT`` so a symlink or junction planted
+        at the path is not followed, and the reparse decision is read from *that* handle via
+        ``GetFileInformationByHandle`` rather than from a prior pathname query. Reading the held handle closes the
+        check-then-open race: an attacker cannot swap the path between validation and use because both act on the same
+        handle. Share mode omits delete so a peer cannot unlink or rename the file out from under a live holder,
+        matching ``os.open``'s ``_SH_DENYNO``.
+
+        ``NtCreateFile`` is used instead of ``CreateFileW`` because its return value carries the raw ``NTSTATUS``.
+        Windows collapses a transient delete-pending name and a permanent access denial into the same Win32
+        ``ERROR_ACCESS_DENIED``; the status keeps them apart, so a real denial fails fast instead of spinning until the
+        caller's timeout (#604).
+
+        The reparse option only guards the final path component; Windows still follows reparse points in intermediate
+        directories. This assumes the lock file sits in a lock directory untrusted users cannot modify. A path with
+        attacker-controlled parent directories would need component-by-component handle validation.
+
+        :param path: the lock file path.
+        :param mode: the permission mode; as ``os.open`` does on Windows, a cleared owner-write bit creates the file
+            read-only. A mode without group and other bits creates it with an owner-only DACL (discretionary access
+            control list, the Windows permission list); any other mode has no Windows counterpart and leaves the file
+            the entries its directory hands down. Both only take effect when the file is created, not when an existing
+            one is opened.
+
+        :param oplock_wait: seconds to wait for the holder of an oplock on the file to answer its break.
+
+        :returns: a file descriptor owning the opened handle, or ``None`` on a sharing violation or a delete-pending
+            name, which the caller should treat as contention and retry.
+
+        :raises BlockingIOError: if an oplock break stays unanswered for *oplock_wait* seconds.
+        :raises OSError: if the path resolves to a reparse point, or the open fails for any other reason, raised with
+            the Win32 error the status maps to. An access denial is raised only once it outlasts a run of probes, since
+            a peer unlinking the file as it releases can make the open answer ``STATUS_ACCESS_DENIED`` for a moment.
+
+        """
+        # Emit the audit event os.open would, so consumers watching "open" still see the path-level open and can veto.
+        sys.audit("open", path, None, os.O_RDWR | os.O_CREAT)
+        read_only = not mode & _OWNER_WRITE
+        owner_only = not mode & 0o077
+        handle, status = _nt_open(path, read_only=read_only, owner_only=owner_only)
+        denied_probes = 0
+        oplock_deadline = time.monotonic() + oplock_wait
+        while True:
+            if status == _STATUS_ACCESS_DENIED:
+                if denied_probes >= _ACCESS_DENIED_PROBES:
+                    break
+                denied_probes += 1
+            elif status == _STATUS_OPLOCK_BREAK_IN_PROGRESS:
+                if time.monotonic() >= oplock_deadline:
+                    break
+            else:
+                break
+            time.sleep(_ACCESS_DENIED_RETRY)
+            handle, status = _nt_open(path, read_only=read_only, owner_only=owner_only)
+        if status == _STATUS_OPLOCK_BREAK_IN_PROGRESS:
+            msg = "oplock break in progress"
+            raise BlockingIOError(EWOULDBLOCK, msg, path)
+        if status != _STATUS_SUCCESS:
+            if status in {_STATUS_SHARING_VIOLATION, _STATUS_DELETE_PENDING}:
+                return None
+            raise _status_error(status, path)
+
+        return _descriptor_for_non_reparse(handle, path, os.O_RDWR)
+
+    def open_read_without_oplock_wait(path: str) -> int:
+        """
+        Open *path* read-only and return a descriptor, without waiting for an oplock holder to answer its break.
+
+        ``os.open`` waits inside the system call until the holder of an oplock on the file answers or closes its handle,
+        so no timeout or ``blocking=False`` ends the wait. A reparse point at *path* is refused rather than followed.
+
+        :param path: the file to read.
+
+        :returns: a read-only file descriptor.
+
+        :raises BlockingIOError: if an oplock break is in progress, which callers treat as contention.
+        :raises FileNotFoundError: if *path* does not exist.
+        :raises OSError: if the open fails for any other reason, or *path* is a reparse point.
+
+        """
+        sys.audit("open", path, None, os.O_RDONLY)
+        return _open_existing_without_oplock_wait(path, _GENERIC_READ | _SYNCHRONIZE, os.O_RDONLY)
+
+    def open_for_delete_without_oplock_wait(path: str) -> int:
+        """
+        Open *path* with delete access and return a descriptor, without waiting for an oplock holder to answer.
+
+        The open handle shares read, write and delete, so a rename of *path* can proceed while the caller keeps it.
+        A holder that took an oplock through another handle is asked to answer by this open, which then raises, so the
+        caller skips the rename instead of waiting for it.
+
+        :param path: the file to rename.
+
+        :returns: a file descriptor owning the handle; the caller closes it.
+
+        :raises BlockingIOError: if an oplock break is in progress, which callers treat as contention.
+        :raises FileNotFoundError: if *path* does not exist.
+        :raises OSError: if the open fails for any other reason, or *path* is a reparse point.
+
+        """
+        return _open_existing_without_oplock_wait(path, _DELETE | _FILE_READ_ATTRIBUTES | _SYNCHRONIZE, os.O_RDONLY)
+
+    def unlink_without_oplock_wait(path: str) -> None:
+        """
+        Delete *path* through a handle that does not wait for an oplock holder to answer its break.
+
+        ``os.unlink`` waits like ``os.open`` does. Here an unanswered break leaves the file in place, which callers
+        accept since deleting a lock file is best effort. A symlink at *path* is deleted as a link.
+
+        :param path: the file to delete.
+
+        :raises FileNotFoundError: if *path* does not exist.
+        :raises OSError: if the open fails for any other reason, such as a sharing violation.
+
+        """
+        sys.audit("os.remove", path, None)
+        handle, status = _nt_create(
+            path,
+            _DELETE | _SYNCHRONIZE,
+            _FILE_ATTRIBUTE_NORMAL,
+            _FILE_SHARE_ALL,
+            _FILE_OPEN,
+            options=_CREATE_OPTIONS | _FILE_DELETE_ON_CLOSE,
+        )
+        if status == _STATUS_SUCCESS:
+            _kernel32.CloseHandle(handle)  # deletes the file
+        elif status != _STATUS_OPLOCK_BREAK_IN_PROGRESS:
+            raise _status_error(status, path)
+
+    def _open_existing_without_oplock_wait(path: str, access: int, flags: int) -> int:
+        handle, status = _nt_create(path, access, _FILE_ATTRIBUTE_NORMAL, _FILE_SHARE_ALL, _FILE_OPEN)
+        if status != _STATUS_SUCCESS:
+            raise _status_error(status, path)
+        return _descriptor_for_non_reparse(handle, path, flags)
+
+    def _status_error(status: int, path: str) -> OSError:
+        if status == _STATUS_OPLOCK_BREAK_IN_PROGRESS:
+            return BlockingIOError(EWOULDBLOCK, "oplock break in progress", path)
+        if status in {_STATUS_OBJECT_NAME_NOT_FOUND, _STATUS_OBJECT_PATH_NOT_FOUND}:
+            return FileNotFoundError(ENOENT, os.strerror(ENOENT), path)
+        winerror = _ntdll.RtlNtStatusToDosError(status)
+        return OSError(None, ctypes.FormatError(winerror).strip(), path, winerror)
+
+    def _descriptor_for_non_reparse(handle: int, path: str, flags: int) -> int:
+        info = _BY_HANDLE_FILE_INFORMATION()
+        # Querying an open handle we just created does not fail.
+        if not _kernel32.GetFileInformationByHandle(handle, ctypes.byref(info)):  # pragma: no cover
+            err = ctypes.get_last_error()
+            _kernel32.CloseHandle(handle)
+            raise ctypes.WinError(err)
+        if info.dwFileAttributes & _FILE_ATTRIBUTE_REPARSE_POINT:
+            _kernel32.CloseHandle(handle)
+            msg = f"Lock file is a reparse point (symlink/junction): {path}"
+            raise OSError(msg)
+
+        try:
+            # O_NOINHERIT mirrors os.open on Windows: the lock fd must not leak into child processes.
+            return msvcrt.open_osfhandle(handle, flags | os.O_NOINHERIT)
+        except BaseException:  # pragma: no cover  # open_osfhandle audits too; a hook raising must not leak the handle
+            _kernel32.CloseHandle(handle)
+            raise
+
+    def _open_deletable_for_reading(path: str) -> int:
+        """
+        Open *path* read-only without blocking a concurrent unlink and without following a reparse point.
+
+        ``os.open`` omits ``FILE_SHARE_DELETE``, so while a process has a file open that way, a delete of it fails with
+        a sharing violation. Every contender reads a strict claim and its owner unlinks it, so a reader that keeps the
+        claim open past the owner's retries makes the release fail.
+        """
+        sys.audit("open", path, None, os.O_RDONLY)
+        handle, status = _nt_create(path, _GENERIC_READ | _SYNCHRONIZE, 0, _FILE_SHARE_ALL, _FILE_OPEN)
+        if status != _STATUS_SUCCESS:
+            winerror = _ntdll.RtlNtStatusToDosError(status)
+            raise OSError(None, ctypes.FormatError(winerror).strip(), path, winerror)
+        try:
+            return msvcrt.open_osfhandle(handle, os.O_RDONLY | os.O_NOINHERIT)
+        except BaseException:  # pragma: no cover  # open_osfhandle audits too; a hook raising must not leak the handle
+            _kernel32.CloseHandle(handle)
+            raise
+
+    def _pin_directory(path: str) -> int:
+        """
+        Open the directory at *path* so that no process can rename or remove it until :func:`_unpin_directory`.
+
+        Windows has no ``dir_fd``, so an operation resolves every path component by name again. A handle on each
+        directory of a record path, opened without following a reparse point, keeps that name bound to the directory
+        checked here until the operation ends.
+
+        :raises NotADirectoryError: when *path* is a junction, a symlink or anything other than a directory.
+        """
+        sys.audit("open", path, None, os.O_RDONLY)
+        # GetFileInformationByHandle needs FILE_READ_ATTRIBUTES; listing access is what takes part in share checks.
+        access = _FILE_LIST_DIRECTORY | _FILE_READ_ATTRIBUTES | _SYNCHRONIZE
+        handle, status = _nt_create(path, access, 0, _FILE_SHARE_READ_WRITE, _FILE_OPEN, _DIRECTORY_OPTIONS)
+        if status != _STATUS_SUCCESS:
+            winerror = _ntdll.RtlNtStatusToDosError(status)
+            raise OSError(None, ctypes.FormatError(winerror).strip(), path, winerror)
+        info = _BY_HANDLE_FILE_INFORMATION()
+        # Querying an open handle we just created does not fail.
+        if not _kernel32.GetFileInformationByHandle(handle, ctypes.byref(info)):  # pragma: no cover
+            error = ctypes.get_last_error()
+            _kernel32.CloseHandle(handle)
+            raise ctypes.WinError(error)
+        if info.dwFileAttributes & _FILE_ATTRIBUTE_REPARSE_POINT:
+            _kernel32.CloseHandle(handle)
+            raise NotADirectoryError(ENOTDIR, "is a junction or symlink, not a directory", path)
+        return handle
+
+    def _unpin_directory(handle: int) -> None:
+        _kernel32.CloseHandle(handle)
+
+    def _is_unlinked(path: str) -> bool:
+        """
+        Report whether *path* is gone or pending deletion, which ``os.open`` reports as the same EACCES as a denial.
+
+        NTFS keeps an unlinked name listed, refusing every open with ``STATUS_DELETE_PENDING``, until the last handle
+        to the file closes. Another process holding such a handle, such as an antivirus scan, can keep it that way for
+        longer than any retry grace, yet the name's owner has already removed it.
+        """
+        handle, status = _nt_create(path, _FILE_READ_ATTRIBUTES | _SYNCHRONIZE, 0, _FILE_SHARE_ALL, _FILE_OPEN)
+        if handle:
+            _kernel32.CloseHandle(handle)
+        return status in {_STATUS_OBJECT_NAME_NOT_FOUND, _STATUS_DELETE_PENDING}
+
+    def _nt_open(path: str, *, read_only: bool, owner_only: bool) -> tuple[int, int]:
+        """
+        Open or create *path* for locking through ``NtCreateFile`` and return ``(handle, status)``.
+
+        Without *owner_only* a file this call creates gets no DACL of its own and inherits its directory's ACL.
+        """
+        attributes = _FILE_ATTRIBUTE_READONLY if read_only else _FILE_ATTRIBUTE_NORMAL
+        descriptor = _owner_only_descriptor() if owner_only else None
+        return _nt_create(
+            path, _DESIRED_ACCESS, attributes, _FILE_SHARE_READ_WRITE, _FILE_OPEN_IF, descriptor=descriptor
+        )
+
+    @cache
+    def _owner_only_descriptor() -> ctypes.c_void_p:
+        # The DACL os.mkdir(mode=0o700) applies, minus the directory-only inheritance flags: protected (P), so the
+        # directory's inheritable entries stay out, with full access (FA) for SYSTEM, Administrators and the owner.
+        # Converted once and never freed: the open retries every few milliseconds while it waits.
+        descriptor = ctypes.c_void_p()
+        if not _advapi32.ConvertStringSecurityDescriptorToSecurityDescriptorW(
+            "D:P(A;;FA;;;SY)(A;;FA;;;BA)(A;;FA;;;OW)", 1, ctypes.byref(descriptor), None
+        ):  # pragma: no cover  # a constant string converts
+            raise ctypes.WinError(ctypes.get_last_error())
+        return descriptor
+
+    def _nt_create(  # ruff:ignore[too-many-arguments, too-many-positional-arguments]  # NtCreateFile's own knobs
+        path: str,
+        access: int,
+        attributes: int,
+        share: int,
+        disposition: int,
+        options: int = _CREATE_OPTIONS,
+        *,
+        descriptor: ctypes.c_void_p | None = None,
+    ) -> tuple[int, int]:
+        """
+        Open *path* through ``NtCreateFile`` and return ``(handle, status)``.
+
+        ``RtlDosPathNameToNtPathName_U_WithStatus`` translates the Win32 path to the NT namespace, handling relative,
+        drive, UNC and extended-length path forms as Win32 itself would, and allocates a buffer that
+        ``RtlFreeUnicodeString`` releases. The handle is ``0`` unless the status is ``STATUS_SUCCESS``: one that comes
+        with ``STATUS_OPLOCK_BREAK_IN_PROGRESS`` is closed here, since the file is not ours until the oplock holder
+        answers.
+        """
+        nt_name = _UNICODE_STRING()
+        status = _ntdll.RtlDosPathNameToNtPathName_U_WithStatus(path, ctypes.byref(nt_name), None, None) & 0xFFFFFFFF
+        if status != _STATUS_SUCCESS:
+            return 0, status
+        try:
+            object_attributes = _OBJECT_ATTRIBUTES()
+            object_attributes.Length = ctypes.sizeof(_OBJECT_ATTRIBUTES)
+            object_attributes.ObjectName = ctypes.pointer(nt_name)
+            object_attributes.Attributes = _OBJ_CASE_INSENSITIVE
+            object_attributes.SecurityDescriptor = descriptor
+            handle = wintypes.HANDLE()
+            io_status = _IO_STATUS_BLOCK()
+            status = (
+                _ntdll.NtCreateFile(
+                    ctypes.byref(handle),
+                    access,
+                    ctypes.byref(object_attributes),
+                    ctypes.byref(io_status),
+                    None,
+                    attributes,
+                    share,
+                    disposition,
+                    options,
+                    None,
+                    0,
+                )
+                & 0xFFFFFFFF
+            )
+        finally:
+            _ntdll.RtlFreeUnicodeString(ctypes.byref(nt_name))
+        if status == _STATUS_OPLOCK_BREAK_IN_PROGRESS:
+            _kernel32.CloseHandle(handle)
+        if status != _STATUS_SUCCESS:
+            return 0, status
+        return handle.value or 0, status
+
+    def _directory_is_private(path: str) -> bool:
+        """
+        Report whether only the current user, ``SYSTEM`` and ``Administrators`` can create or remove names in *path*.
+
+        A directory whose owner is anyone else can have its ACL rewritten by that owner. Entries that only a child
+        inherits count too, since the DACL says nothing more precise about who may write.
+        """
+        owner, dacl, descriptor = ctypes.c_void_p(), ctypes.c_void_p(), ctypes.c_void_p()
+        error = _advapi32.GetNamedSecurityInfoW(
+            path,
+            1,  # SE_FILE_OBJECT
+            0x1 | 0x4,  # OWNER_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION
+            ctypes.byref(owner),
+            None,
+            ctypes.byref(dacl),
+            None,
+            ctypes.byref(descriptor),
+        )
+        if error == _ERROR_ACCESS_DENIED:
+            # C:\Windows\Temp is one. Anything that cannot be proven private is not.
+            return False
+        if error:  # pragma: no cover  # the directory was opened or listed an instant earlier
+            raise ctypes.WinError(error)
+        try:
+            # SYSTEM, Administrators, CREATOR OWNER and OWNER RIGHTS; the last two stand for the owner.
+            trusted = {_sid_from_text(text) for text in ("S-1-5-18", "S-1-5-32-544", "S-1-3-0", "S-1-3-4")}
+            trusted.add(_user_sid())
+            # A missing DACL grants everyone full access.
+            return (
+                bool(dacl.value)
+                and _sid_at(cast("int", owner.value)) in trusted
+                and _name_writers(cast("int", dacl.value)) <= trusted
+            )
+        finally:
+            _kernel32.LocalFree(descriptor)
+
+    def _name_writers(dacl: int) -> set[bytes]:
+        (count,) = struct.unpack("<4xH2x", ctypes.string_at(dacl, 8))
+        writers = set()
+        offset = 8
+        for _ in range(count):
+            ace_type, _flags, ace_size, mask = struct.unpack("<BBHI", ctypes.string_at(dacl + offset, 8))
+            # Allowed and allowed-callback ACEs share a layout; object ACEs exist only in directory services. The check
+            # is conservative: any right that can turn into creating a name counts, namely FILE_ADD_FILE,
+            # FILE_ADD_SUBDIRECTORY, FILE_DELETE_CHILD, WRITE_DAC, WRITE_OWNER, GENERIC_WRITE and GENERIC_ALL.
+            if ace_type in {0, 9} and mask & (0x2 | 0x4 | 0x40 | 0x40000 | 0x80000 | 0x40000000 | 0x10000000):
+                writers.add(_sid_at(dacl + offset + 8))
+            offset += ace_size
+        return writers
+
+    def _user_sid() -> bytes:
+        token = wintypes.HANDLE()
+        token_query: Final = 0x0008
+        open_as_self: Final = True
+        # An impersonating thread acts as the account it impersonates, which is the one whose names the lock creates.
+        if not (
+            _advapi32.OpenThreadToken(_kernel32.GetCurrentThread(), token_query, open_as_self, ctypes.byref(token))
+            or _advapi32.OpenProcessToken(_kernel32.GetCurrentProcess(), token_query, ctypes.byref(token))
+        ):  # pragma: no cover  # every process may query its own token
+            raise ctypes.WinError(ctypes.get_last_error())
+        try:
+            size = wintypes.DWORD()
+            _advapi32.GetTokenInformation(token, 1, None, 0, ctypes.byref(size))
+            buffer = ctypes.create_string_buffer(size.value)
+            if not _advapi32.GetTokenInformation(
+                token, 1, buffer, size, ctypes.byref(size)
+            ):  # pragma: no cover  # the buffer has the size the first call asked for
+                raise ctypes.WinError(ctypes.get_last_error())
+            return _sid_at(cast("int", ctypes.c_void_p.from_buffer(buffer).value))
+        finally:
+            _kernel32.CloseHandle(token)
+
+    def _sid_from_text(text: str) -> bytes:
+        revision, authority, *subauthorities = (int(part) for part in text.removeprefix("S-").split("-"))
+        return (
+            struct.pack("<BB", revision, len(subauthorities))
+            + authority.to_bytes(6, "big")
+            + struct.pack(f"<{len(subauthorities)}I", *subauthorities)
+        )
+
+    def _sid_at(address: int) -> bytes:
+        return ctypes.string_at(address, 8 + 4 * ctypes.string_at(address + 1, 1)[0])
+
+    def _make_private_directory(path: str) -> None:
+        """Create *path* with the owner-only descriptor, so that nobody else can add a name to it."""
+        attributes = _SECURITY_ATTRIBUTES(
+            nLength=ctypes.sizeof(_SECURITY_ATTRIBUTES),
+            lpSecurityDescriptor=_owner_only_descriptor(),
+            bInheritHandle=False,
+        )
+        if not _kernel32.CreateDirectoryW(path, ctypes.byref(attributes)):  # pragma: no cover  # the name is fresh
+            raise ctypes.WinError(ctypes.get_last_error())
+
+    @contextmanager
+    def _pinned(path: str) -> Generator[tuple[int, int]]:
+        """Hold *path* open without delete sharing, which keeps its name from being renamed or removed."""
+        with _opened(path, _FILE_SHARE_READ_WRITE) as handle:
+            yield _identity_of(handle)
+
+    def _identity_at(path: str) -> tuple[int, int]:
+        with _opened(path, _FILE_SHARE_ALL) as handle:
+            return _identity_of(handle)
+
+    def _identity_of_fd(fd: int) -> tuple[int, int]:
+        return _identity_of(msvcrt.get_osfhandle(fd))
+
+    @contextmanager
+    def _opened(path: str, share: int) -> Generator[int]:
+        # The final component is opened as itself, never through a reparse point.
+        handle = _kernel32.CreateFileW(
+            path,
+            _FILE_READ_ATTRIBUTES,
+            share,
+            None,
+            3,  # OPEN_EXISTING
+            0x02000000 | 0x00200000,  # FILE_FLAG_BACKUP_SEMANTICS opens a directory; FILE_FLAG_OPEN_REPARSE_POINT
+            None,
+        )
+        if handle in {None, _INVALID_HANDLE_VALUE}:  # pragma: no cover  # callers open a name they just made or listed
+            raise ctypes.WinError(ctypes.get_last_error())
+        try:
+            yield cast("int", handle)
+        finally:
+            _kernel32.CloseHandle(handle)
+
+    def _identity_of(handle: int) -> tuple[int, int]:
+        info = _BY_HANDLE_FILE_INFORMATION()
+        if not _kernel32.GetFileInformationByHandle(handle, ctypes.byref(info)):  # pragma: no cover
+            raise ctypes.WinError(ctypes.get_last_error())
+        return info.dwVolumeSerialNumber, info.nFileIndexHigh << 32 | info.nFileIndexLow
+
+else:  # pragma: win32 no cover
+
+    class WindowsFileLock(BaseFileLock):
+        """Uses ``LockFileEx`` to hard lock a byte range of the lock file on Windows systems."""
+
+        def _acquire(self) -> None:
+            raise NotImplementedError
+
+        def _release(self) -> None:
+            raise NotImplementedError
+
+
+__all__ = [
+    "WindowsFileLock",
+    "_directory_is_private",
+    "_identity_at",
+    "_identity_of_fd",
+    "_is_unlinked",
+    "_make_private_directory",
+    "_open_deletable_for_reading",
+    "_open_non_reparse_fd",
+    "_pin_directory",
+    "_pinned",
+    "_unpin_directory",
+    "open_for_delete_without_oplock_wait",
+    "open_read_without_oplock_wait",
+    "unlink_without_oplock_wait",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/asyncio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/asyncio.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c3703737ec510da51792b19924d066099afaea6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/asyncio.py
@@ -0,0 +1,925 @@
+"""An asyncio-based implementation of the file lock."""
+
+from __future__ import annotations
+
+__lazy_modules__ = [
+    "asyncio",
+    "concurrent",
+    "contextlib",
+    "filelock._async",
+    "filelock._error",
+    "filelock._util",
+    "functools",
+    "inspect",
+    "threading",
+]
+
+import asyncio
+import contextlib
+import functools
+import logging
+import os
+import sys
+import time
+from concurrent import futures
+from dataclasses import dataclass, field, fields
+from inspect import iscoroutinefunction
+from threading import RLock
+from typing import TYPE_CHECKING, Final, NoReturn, TypeVar, cast
+
+from filelock._api import (
+    _UNSET_FILE_MODE,
+    BaseFileLock,
+    CloseErrorPolicy,
+    ContextErrorPolicy,
+    FileLockContext,
+    FileLockMeta,
+    ThreadLocalFileContext,
+    _append_exception_context,
+    _canonical,
+    _delegate_to_current,
+    _ExtraValue,
+    _fork_transition,
+    _grouped_errors,
+    _is_system_call_failure,
+    _raise_body_and_release,
+    _raise_chained_errors,
+    _raise_cleanup_errors,
+    _raise_grouped_errors,
+    _register_fork_object,
+    _resolve_poll_interval,
+    _resolve_timeout,
+)
+from filelock._async import (
+    _AsyncTransitionGate,
+    _AsyncTransitionUnavailableError,
+    _BackendOutcome,
+    _capture_awaitable,
+    _capture_call,
+    _drain_future,
+    _future_result,
+    _run_in_executor,
+    _wait_until_done,
+)
+from filelock._error import Timeout
+from filelock._lease import SoftFileLease
+from filelock._soft import SoftFileLock
+from filelock._strict import StrictSoftFileLock
+from filelock._unix import UnixFileLock
+from filelock._util import ensure_directory_exists
+from filelock._windows import WindowsFileLock
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable, Coroutine, Hashable, Mapping
+    from types import TracebackType
+    from typing import Self
+
+
+_LOGGER: Final[logging.Logger] = logging.getLogger("filelock")
+_ASYNC_RELEASE_CANCELLATION_ERRORS: Final[str] = "lock release cancellation and backend release both failed"
+_ASYNC_CONTEXT_RELEASE_ERRORS: Final[str] = "context body, release cancellation, and backend release failed"
+_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR: Final[str] = "_filelock_async_release_cancellation"
+_ASYNC_RELEASE_CANCELLATION_MARKER: Final[list[None]] = []
+_FINALIZER_RELEASES: Final[set[asyncio.Task[None] | futures.Future[None]]] = set()
+
+_AT = TypeVar("_AT", bound="BaseAsyncFileLock")
+_T = TypeVar("_T")
+
+
+class AsyncFileLockMeta(FileLockMeta):
+    def __call__(  # ruff:ignore[too-many-arguments]  # forwards the public constructor's documented parameters
+        cls: type[_AT],  # ruff:ignore[invalid-first-argument-name-for-method]  # metaclass __call__ receives the class being constructed
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = False,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        run_in_executor: bool = True,
+        executor: futures.Executor | None = None,
+        **kwargs: _ExtraValue,
+    ) -> _AT:
+        if thread_local and run_in_executor:
+            msg = "run_in_executor is not supported when thread_local is True"
+            raise ValueError(msg)
+        return super().__call__(  # a subclass may add options of its own, as AsyncSoftFileLease does
+            **kwargs,
+            lock_file=lock_file,
+            timeout=timeout,
+            mode=mode,
+            thread_local=thread_local,
+            blocking=blocking,
+            is_singleton=is_singleton,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+            context_error_policy=context_error_policy,
+            close_error_policy=close_error_policy,
+            fallback_to_soft=fallback_to_soft,
+            preserve_lock_file=preserve_lock_file,
+            on_acquired=on_acquired,
+            loop=loop,
+            run_in_executor=run_in_executor,
+            executor=executor,
+        )
+
+
+class BaseAsyncFileLock(BaseFileLock, metaclass=AsyncFileLockMeta):
+    """
+    Base class for asynchronous file locks.
+
+    .. versionadded:: 3.15.0
+
+    """
+
+    _deadlock_holder_desc: str = "BaseAsyncFileLock instance in this task"
+    _constructor_lifetime_warning_stacklevel: int = 4
+
+    @staticmethod
+    def _deadlock_scope() -> Hashable | None:
+        # One event loop thread runs every task, so a thread-scoped registry cannot tell a same-task reacquire
+        # (a real deadlock: the polling task never reaches its own release) from another task queuing behind the
+        # holder (no deadlock: each poll yields, so the holder runs on and releases). Only the first may fail
+        # fast, so scope holders to the task.
+        return asyncio.current_task()
+
+    def __init__(  # ruff:ignore[too-many-arguments]  # public constructor: one parameter per documented lock option
+        self,
+        lock_file: str | os.PathLike[str],
+        timeout: float = -1,
+        mode: int = _UNSET_FILE_MODE,
+        thread_local: bool = False,  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        *,
+        blocking: bool = True,
+        is_singleton: bool = False,
+        poll_interval: float = 0.05,
+        lifetime: float | None = None,
+        context_error_policy: ContextErrorPolicy = "chain",
+        close_error_policy: CloseErrorPolicy = "default",
+        fallback_to_soft: bool = True,
+        preserve_lock_file: bool = False,
+        on_acquired: Callable[[int], None] | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+        run_in_executor: bool = True,
+        executor: futures.Executor | None = None,
+    ) -> None:
+        """
+        Create a new lock object.
+
+        :param lock_file: path to the file
+        :param timeout: default timeout when acquiring the lock, in seconds. It will be used as fallback value in the
+            acquire method, if no timeout value (``None``) is given. If you want to disable the timeout, set it to a
+            negative value. A timeout of 0 means that there is exactly one attempt to acquire the file lock.
+        :param mode: file permissions for the lockfile. When not specified, the OS controls permissions via umask and
+            default ACLs, preserving POSIX default ACL inheritance in shared directories.
+        :param thread_local: Whether this object's internal context should be thread local or not. If this is set to
+            ``False`` (the default) then the lock will be reentrant across threads. When ``True``, **all fields of the
+            lock's internal context are per-thread**, including the configuration values ``poll_interval``, ``timeout``,
+            ``blocking``, ``mode``, and ``lifetime``. Setting one of these properties from one thread does not change
+            the value seen by another thread; threads that did not perform the write continue to see the value supplied
+            at construction time. ``mode`` has no setter, so construction is the only place it is ever set. If you need
+            configuration values to be visible across threads, construct the lock with ``thread_local=False``.
+        :param blocking: whether the lock should be blocking or not
+        :param is_singleton: If this is set to ``True`` then only one instance of this class will be created per lock
+            file. This is useful if you want to use the lock object for reentrant locking without needing to pass the
+            same object around.
+        :param poll_interval: default interval for polling the lock file, in seconds. It will be used as fallback value
+            in the acquire method, if no poll_interval value (``None``) is given.
+        :param lifetime: for :class:`AsyncSoftFileLock`, the age in seconds after which a waiting process may delete
+            the marker, even while its holder remains alive. This legacy expiry mode does not provide strict mutual
+            exclusion. ``None`` (the default) disables age-based expiry. Native OS locks (:class:`AsyncFileLock`)
+            cannot be revoked by file age and ignore a non-``None`` ``lifetime`` with a warning.
+        :param context_error_policy: how a context manager reconciles a failure in its body with a failure while
+            releasing on exit. ``"chain"`` (the default) keeps Python's behavior: the release error propagates with the
+            body error in its ``__context__``. ``"group"`` raises a :class:`BaseExceptionGroup` holding the body error
+            first and the release error second, so neither hides the other.
+        :param close_error_policy: for native locks (:class:`AsyncFileLock`), what to do with an ``os.close`` failure
+            after the OS unlock has already committed. ``"default"`` keeps each platform's historical behavior,
+            ``"raise"`` always propagates the ``OSError``, and ``"suppress"`` always ignores it.
+        :param fallback_to_soft: for :class:`AsyncFileLock`, whether to fall back to soft existence locking when
+            ``flock`` returns ``ENOSYS``. ``True`` (default) keeps the fallback; ``False`` propagates the error.
+        :param preserve_lock_file: for native locks (:class:`AsyncFileLock`), whether filelock promises not to unlink
+            the lock pathname on release. ``False`` (default) keeps each backend's cleanup; ``True`` keeps a stable file
+            identity (Windows skips its unlink, Unix refuses the ``ENOSYS`` soft fallback). :class:`AsyncSoftFileLock`
+            rejects ``True``.
+        :param on_acquired: for native locks (:class:`AsyncFileLock`), a callable invoked with the borrowed lock
+            descriptor once per physical acquisition, after the lock is held but before
+            :meth:`~BaseAsyncFileLock.acquire` returns. With ``run_in_executor=True`` (the default) it runs in the
+            backend executor. It must not close or unlock the descriptor; a raise rolls the acquisition back.
+            :class:`AsyncSoftFileLock` rejects it.
+        :param loop: the event loop a garbage-collected lock schedules its release on when no loop runs in the
+            collecting thread. :meth:`~BaseAsyncFileLock.acquire` and :meth:`~BaseAsyncFileLock.release` always run
+            on the loop that awaits them.
+        :param run_in_executor: If this is set to ``True`` then the lock will be acquired in an executor.
+        :param executor: The executor to use. If not specified, the default executor will be used.
+
+        """
+        self._creator_pid = os.getpid()
+        self._holder_id = id(self)
+        self._is_thread_local = thread_local
+        self._is_singleton = is_singleton
+        self._context_error_policy = context_error_policy  # already validated by the metaclass
+        self._close_error_policy = close_error_policy  # already validated by the metaclass
+        self._fallback_to_soft = fallback_to_soft
+        self._preserve_lock_file = preserve_lock_file  # already validated by the metaclass
+        self._on_acquired = on_acquired  # already validated by the metaclass
+        # BaseFileLock.__init__ never runs here, and the finalizer releases thread-local holds through these.
+        self._transition_lock = RLock()
+        self._thread_holds = {}
+        self._thread_pending = {}
+
+        self._async_context: Final[AsyncFileLockContext] = (
+            AsyncThreadLocalFileContext if thread_local else AsyncFileLockContext
+        )(
+            lock_file=os.fspath(lock_file),
+            timeout=timeout,
+            mode=mode,
+            blocking=blocking,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+            loop=loop,
+            run_in_executor=run_in_executor,
+            executor=executor,
+        )
+        # BaseFileLock declares _context as FileLockContext; narrowing that writable attribute here is unsound.
+        self._context = self._async_context
+        _register_fork_object(self)
+
+    def _singleton_extra_mismatches(self, kwargs: Mapping[str, _ExtraValue], /) -> dict[str, tuple[str, str]]:
+        mismatches = super()._singleton_extra_mismatches(kwargs)
+        # Loops and executors compare by identity: a different one schedules the lock's work elsewhere.
+        mismatches.update(
+            (name, (str(kwargs[name]), str(value)))
+            for name, value in (("loop", self.loop), ("executor", self.executor))
+            if kwargs[name] is not value
+        )
+        if kwargs["run_in_executor"] != self.run_in_executor:
+            mismatches["run_in_executor"] = (str(kwargs["run_in_executor"]), str(self.run_in_executor))
+        return mismatches
+
+    @property
+    def run_in_executor(self) -> bool:
+        """Whether run in executor."""
+        return self._async_context.run_in_executor
+
+    @property
+    def executor(self) -> futures.Executor | None:
+        """The executor."""
+        return self._async_context.executor
+
+    @executor.setter
+    def executor(self, value: futures.Executor | None) -> None:  # pragma: no cover
+        """
+        Change the executor.
+
+        :param futures.Executor | None value: the new executor or ``None``
+
+        """
+        self._async_context.executor = value
+
+    @property
+    def loop(self) -> asyncio.AbstractEventLoop | None:
+        """The event loop."""
+        return self._async_context.loop
+
+    async def acquire(  # ty: ignore[invalid-method-override]
+        self,
+        timeout: float | None = None,
+        poll_interval: float | None = None,
+        *,
+        blocking: bool | None = None,
+        cancel_check: Callable[[], bool] | None = None,
+    ) -> AsyncAcquireReturnProxy:
+        """
+        Try to acquire the file lock.
+
+        :param timeout: maximum wait time for acquiring the lock, ``None`` means use the default
+            :attr:`~BaseFileLock.timeout` is and if ``timeout < 0``, there is no timeout and this method will block
+            until the lock could be acquired
+        :param poll_interval: interval of trying to acquire the lock file, ``None`` means use the default
+            :attr:`~BaseFileLock.poll_interval`
+        :param blocking: whether to retry until this call holds the lock or the timeout expires, ``None`` means use
+            the default :attr:`~BaseFileLock.blocking`. ``False`` makes one attempt and raises :class:`~Timeout` on
+            failure.
+        :param cancel_check: a callable returning ``True`` when the acquisition should be canceled. Checked on each poll
+            iteration. When triggered, raises :class:`~Timeout` just like an expired timeout.
+
+        :returns: a context object that will unlock the file when the context is exited
+
+        :raises Timeout: if fails to acquire lock within the timeout period
+        :raises ValueError: if a blocking call gets a ``nan`` timeout, or *poll_interval* exceeds
+            :data:`threading.TIMEOUT_MAX`
+
+        .. code-block:: python
+
+            # You can use this method in the context manager (recommended)
+            async with await lock.acquire():
+                pass
+
+            # Or use an equivalent try-finally construct:
+            await lock.acquire()
+            try:
+                pass
+            finally:
+                await lock.release()
+
+        """
+        self._raise_if_inherited()
+        if timeout is None:
+            timeout = self._context.timeout
+
+        if blocking is None:
+            blocking = self._context.blocking
+
+        if poll_interval is None:
+            poll_interval = self._context.poll_interval
+        poll_interval = _resolve_poll_interval(poll_interval)
+        timeout = _resolve_timeout(timeout, blocking=blocking)
+
+        start_time = time.perf_counter()
+        try:
+            return await self._acquire_with_admission(
+                blocking=blocking,
+                cancel_check=cancel_check,
+                timeout=timeout,
+                poll_interval=poll_interval,
+                start_time=start_time,
+            )
+        except _AsyncTransitionUnavailableError:
+            raise Timeout(self.lock_file) from None
+
+    async def _acquire_with_admission(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> AsyncAcquireReturnProxy:
+        async with self._async_context.transition_gate.hold_for_acquire(
+            blocking=blocking,
+            cancel_check=cancel_check,
+            deadline=None if timeout < 0 else start_time + timeout,
+            poll_interval=poll_interval,
+        ):
+            # Re-entry only counts, so it skips the executor round trip that resolving the path costs.
+            if self.is_locked:
+                self._context.lock_counter += 1
+                return AsyncAcquireReturnProxy(lock=self)
+            # A canceled provisional acquire must finish rollback before another caller can claim its descriptor.
+            canonical = await self._off_loop(functools.partial(_canonical, self.lock_file))
+            self._context.lock_counter += 1
+            self._raise_if_would_deadlock(canonical, timeout=timeout, blocking=blocking)
+            self._pin_lock_path(canonical)
+            try:
+                await self._async_poll_until_acquired(
+                    blocking=blocking,
+                    cancel_check=cancel_check,
+                    timeout=timeout,
+                    poll_interval=poll_interval,
+                    start_time=start_time,
+                )
+            except BaseException:
+                self._reconcile_failed_acquire(canonical)
+                raise
+            self._commit_acquire(canonical)
+            return AsyncAcquireReturnProxy(lock=self)
+
+    async def _off_loop(self, call: Callable[[], _T]) -> _T:
+        # A slow mount stalls a filesystem call, and the loop with it; a coroutine backend runs on the loop anyway.
+        if not self.run_in_executor or iscoroutinefunction(self._acquire):
+            return call()
+        future = _run_in_executor(asyncio.get_running_loop(), self.executor, call)
+        await _wait_until_done(future)
+        return _future_result(future)
+
+    async def _async_poll_until_acquired(
+        self,
+        *,
+        blocking: bool,
+        cancel_check: Callable[[], bool] | None,
+        timeout: float,
+        poll_interval: float,
+        start_time: float,
+    ) -> None:
+        lock_id = id(self)
+        lock_filename = self.lock_file
+        await self._off_loop(functools.partial(ensure_directory_exists, self._lock_path))
+        while True:
+            self._raise_if_inherited()
+            _LOGGER.debug("Attempting to acquire lock %s on %s", lock_id, lock_filename)
+            await self._run_acquire_attempt()
+            self._raise_if_inherited()
+            if self.is_locked:
+                _LOGGER.debug("Lock %s acquired on %s", lock_id, lock_filename)
+                return
+            if self._check_give_up(
+                blocking=blocking,
+                cancel_check=cancel_check,
+                timeout=timeout,
+                start_time=start_time,
+            ):
+                raise Timeout(lock_filename, await self._off_loop(self._unprobeable_holder))
+            delay = poll_interval
+            if timeout >= 0:
+                delay = min(delay, max(start_time + timeout - time.perf_counter(), 0.0))
+            _LOGGER.debug("Lock %s not acquired on %s, waiting %s seconds ...", lock_id, lock_filename, delay)
+            await asyncio.sleep(delay)
+
+    async def _run_acquire_attempt(self) -> None:
+        acquire_future = self._start_internal_method(
+            self._acquire_with_fork_tracking_async
+            if iscoroutinefunction(self._acquire)
+            else self._break_expired_and_acquire
+        )
+        try:
+            await _wait_until_done(acquire_future)
+        except asyncio.CancelledError as cancellation:
+            acquire_error: BaseException | None = None
+            try:
+                await _drain_future(acquire_future)
+            except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                acquire_error = error
+
+            rollback_error: BaseException | None = None
+            if self.is_locked:
+                try:
+                    await _drain_future(self._start_tracked_release())
+                except BaseException as error:  # ruff:ignore[blind-except]  # reported with the cancellation below
+                    rollback_error = error
+
+            if acquire_error is not None:
+                if rollback_error is not None:  # pragma: needs fcntl
+                    self._raise_cancelled_errors(
+                        "lock acquisition cancellation, backend attempt, and rollback failed",
+                        cancellation,
+                        acquire_error,
+                        rollback_error,
+                    )
+                self._raise_cancelled_errors(
+                    "lock acquisition cancellation and backend attempt both failed", cancellation, acquire_error
+                )
+            if rollback_error is not None:
+                self._raise_cancelled_errors(
+                    "lock acquisition cancellation and rollback both failed", cancellation, rollback_error
+                )
+            raise
+        try:
+            _future_result(acquire_future)
+        except asyncio.CancelledError as acquire_error:
+            await self._rollback_backend_cancelled_acquire(acquire_error)
+
+    async def _rollback_backend_cancelled_acquire(self, acquire_error: asyncio.CancelledError) -> NoReturn:
+        if self.is_locked:
+            try:
+                await _drain_future(self._start_tracked_release())
+            except BaseException as rollback_error:  # ruff:ignore[blind-except]  # both backend errors must surface
+                self._raise_acquire_rollback_errors(acquire_error, rollback_error)
+        raise acquire_error
+
+    def _raise_acquire_rollback_errors(self, acquire_error: BaseException, rollback_error: BaseException) -> NoReturn:
+        if self._context_error_policy == "group":
+            _raise_grouped_errors("lock acquisition backend and rollback both failed", acquire_error, rollback_error)
+        _raise_chained_errors(acquire_error, rollback_error)
+
+    def _raise_cancelled_errors(
+        self,
+        message: str,
+        cancellation: asyncio.CancelledError,
+        first_error: BaseException,
+        second_error: BaseException | None = None,
+    ) -> NoReturn:
+        if self._context_error_policy == "group":
+            marker = (
+                (_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR, _ASYNC_RELEASE_CANCELLATION_MARKER)
+                if message == _ASYNC_RELEASE_CANCELLATION_ERRORS
+                else None
+            )
+            if second_error is None:
+                _raise_grouped_errors(message, cancellation, first_error, marker=marker)
+            _raise_grouped_errors(message, cancellation, first_error, second_error, marker=marker)
+        if (context := first_error.__context__) is not None and context is not cancellation:
+            if (cancellation_context := cancellation.__context__) is not None:
+                _append_exception_context(context, cancellation_context)
+            cancellation.__context__ = context
+        first_error.__context__ = cancellation
+        _raise_chained_errors(first_error, second_error)
+
+    async def release(self, force: bool = False) -> None:  # ty: ignore[invalid-method-override]  # ruff:ignore[boolean-type-hint-positional-argument, boolean-default-value-positional-argument]  # public API: positional bool kept for backwards compatibility
+        """
+        Release the file lock. The lock is only completely released when the lock counter reaches 0. The lock file
+        itself may be deleted automatically, the behavior is platform-specific.
+
+        :param force: If true, the lock counter is ignored and the lock is released in every case.
+
+        """
+        if self._creator_pid != os.getpid() or not self.is_locked:
+            return
+        async with self._async_context.transition_gate.hold():
+            await self._release_serialized(force=force)
+
+    async def _release_serialized(self, *, force: bool) -> None:
+        counter_before: Final = self._context.lock_counter
+        if not self.is_locked:
+            return
+        if not force and self._context.lock_counter > 1:
+            self._context.lock_counter -= 1
+            return
+
+        try:
+            await self._release_through_backend()
+        except BaseException as release_error:
+            if self._release_interrupted_before_commit(counter_before, release_error):
+                with contextlib.suppress(Exception):
+                    self._release_with_fork_tracking()
+                self._commit_release_if_released()
+            raise
+
+    def _release_interrupted_before_commit(self, counter_before: int, release_error: BaseException) -> bool:
+        # Same rule as the sync release: a handler that raised before anything committed leaves the counter as it was,
+        # and only then does a second attempt release the hold. A worker thread never runs a handler, so a lock that
+        # runs its backend in the executor has nothing to retry.
+        return (
+            counter_before == self._context.lock_counter
+            and self.is_locked
+            and not self.run_in_executor
+            and not iscoroutinefunction(self._release)
+            and not isinstance(release_error, asyncio.CancelledError)
+            and not _is_system_call_failure(release_error)
+        )
+
+    async def _release_through_backend(self) -> None:
+        lock_id, lock_filename = id(self), self.lock_file
+        _LOGGER.debug("Attempting to release lock %s on %s", lock_id, lock_filename)
+        release_future = self._start_tracked_release()
+        try:
+            await _wait_until_done(release_future)
+        except asyncio.CancelledError as cancellation:
+            try:
+                await _drain_future(release_future)
+            except BaseException as release_error:  # ruff:ignore[blind-except]  # cancellation and backend failure must both surface
+                self._commit_release_if_released()
+                self._raise_cancelled_errors(_ASYNC_RELEASE_CANCELLATION_ERRORS, cancellation, release_error)
+            self._commit_release()
+            raise
+        try:
+            _future_result(release_future)
+        except BaseException:  # state follows the backend for control-flow exceptions too
+            self._commit_release_if_released()
+            raise
+        self._commit_release()
+        _LOGGER.debug("Lock %s released on %s", lock_id, lock_filename)
+
+    def _commit_release_if_released(self) -> None:
+        # Commit only when the backend actually unlocked (close or unlink failed after the OS unlock). If the lock is
+        # still held, keep the counter so a later release can retry.
+        if not self.is_locked:
+            self._commit_release()
+
+    def _start_internal_method(
+        self, method: Callable[[], None] | Callable[[], Coroutine[None, None, None]]
+    ) -> asyncio.Future[_BackendOutcome[None]]:
+        if iscoroutinefunction(method):
+            return asyncio.create_task(_capture_awaitable(cast("Callable[[], Coroutine[None, None, None]]", method)()))
+        loop = asyncio.get_running_loop()
+        sync_method = cast("Callable[[], None]", method)
+        if self.run_in_executor:
+            return _run_in_executor(loop, self.executor, sync_method)
+        future: asyncio.Future[_BackendOutcome[None]] = loop.create_future()
+        future.set_result(_capture_call(sync_method))
+        return future
+
+    def _start_tracked_release(self) -> asyncio.Future[_BackendOutcome[None]]:
+        return self._start_internal_method(
+            self._release_with_fork_tracking_async
+            if iscoroutinefunction(self._release)
+            else self._release_with_fork_tracking
+        )
+
+    def _break_expired_and_acquire(self) -> None:
+        # Runs as one backend call so the lifetime check's lstat and unlink stay off the event loop with the acquire.
+        self._try_break_expired_lock()
+        self._acquire_with_fork_tracking()
+
+    async def _acquire_with_fork_tracking_async(self) -> None:
+        self._try_break_expired_lock()
+        with _fork_transition(self):
+            try:
+                await cast("Callable[[], Awaitable[None]]", self._acquire)()
+            except BaseException as acquisition_error:
+                await self._rollback_failed_acquire_async(acquisition_error)
+                raise
+            try:
+                self._register_context_descriptor()
+            except BaseException as registration_error:  # cancellation must roll back the descriptor
+                await self._rollback_failed_registration_async(registration_error)
+                raise
+        if self.is_locked:
+            await self._invoke_on_acquired_async()
+
+    async def _rollback_failed_acquire_async(self, acquisition_error: BaseException) -> None:
+        if not self.is_locked:
+            return
+        registration_error: BaseException | None = None
+        tracking_error: BaseException | None = None
+        try:
+            self._register_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # preserve registration and acquisition failures
+            registration_error = error
+            try:
+                # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+                self._register_unverified_context_descriptor()
+            except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+                tracking_error = error
+        try:
+            await _drain_future(self._start_tracked_release())
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and acquisition failures
+            if registration_error is None and tracking_error is None:
+                self._raise_acquire_rollback_errors(acquisition_error, rollback_error)
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed",
+                acquisition_error,
+                registration_error,
+                tracking_error,
+                rollback_error,
+            )
+        if registration_error is not None:
+            _raise_cleanup_errors(
+                "lock acquisition cleanup failed", acquisition_error, registration_error, tracking_error
+            )
+
+    async def _rollback_failed_registration_async(self, registration_error: BaseException) -> None:
+        tracking_error: BaseException | None = None
+        try:
+            # Rollback may fail too; retain the fd so a child can close it without another identity probe.
+            self._register_unverified_context_descriptor()
+        except BaseException as error:  # ruff:ignore[blind-except]  # pragma: no cover - allocation/control-flow during fallback
+            tracking_error = error
+        try:
+            await _drain_future(self._start_tracked_release())
+        except BaseException as rollback_error:  # ruff:ignore[blind-except]  # preserve rollback and registration failures
+            _raise_cleanup_errors(
+                "descriptor registration cleanup failed", registration_error, tracking_error, rollback_error
+            )
+        if tracking_error is not None:  # pragma: no cover - requires failed in-memory fallback
+            _raise_cleanup_errors("descriptor registration cleanup failed", registration_error, tracking_error)
+
+    async def _invoke_on_acquired_async(self) -> None:
+        if self._on_acquired is None or self._context.lock_counter != 1:
+            return
+        try:
+            self._on_acquired(cast("int", self._context.lock_file_fd))
+        except BaseException as callback_error:  # caller control-flow errors must release the lock
+            callback_context = callback_error.__context__
+            try:
+                await _drain_future(self._start_tracked_release())
+            except BaseException as release_error:  # ruff:ignore[blind-except]  # both errors surface via the group below
+                _raise_body_and_release(callback_error, release_error)
+            callback_error.__context__ = callback_context
+            raise
+
+    async def _release_with_fork_tracking_async(self) -> None:
+        with _fork_transition(self):
+            try:
+                await cast("Callable[[], Awaitable[None]]", self._release)()
+            finally:
+                self._unregister_released_descriptor()
+
+    def __enter__(self) -> NoReturn:
+        """Sync context manager entry is not supported because lock acquisition is a coroutine."""
+        msg = "Use `async with`: acquire/release are coroutines and cannot be awaited in a sync context manager."
+        raise NotImplementedError(msg)
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """Sync context manager exit is not supported because lock release is a coroutine."""
+        msg = "Use `async with`: acquire/release are coroutines and cannot be awaited in a sync context manager."
+        raise NotImplementedError(msg)
+
+    async def __aenter__(self) -> Self:
+        """
+        Acquire the lock.
+
+        :returns: the lock object
+
+        """
+        await self.acquire()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        """
+        Release the lock, reconciling a release failure with any body failure per :attr:`context_error_policy`.
+
+        :param exc_type: the exception type if raised
+        :param exc_value: the exception value if raised
+        :param traceback: the exception traceback if raised
+
+        """
+        await self._release_in_context(exc_value)
+
+    async def _release_in_context(  # ty: ignore[invalid-method-override]
+        self, body_error: BaseException | None
+    ) -> None:
+        # The async counterpart of BaseFileLock._release_in_context: await release, then apply the same policy.
+        try:
+            await self.release()
+        except BaseException as release_error:
+            if body_error is None:
+                raise
+            if self._context_error_policy == "chain":
+                _append_exception_context(release_error, body_error)
+                raise
+            if (
+                errors := _grouped_errors(
+                    release_error,
+                    _ASYNC_RELEASE_CANCELLATION_ERRORS,
+                    (_ASYNC_RELEASE_CANCELLATION_MARKER_ATTR, _ASYNC_RELEASE_CANCELLATION_MARKER),
+                )
+            ) is not None:
+                match errors:
+                    # The marker is only ever set on a (CancelledError, backend_error) pair, so this always matches.
+                    case (asyncio.CancelledError() as cancellation, backend_error):  # pragma: no branch
+                        _raise_grouped_errors(_ASYNC_CONTEXT_RELEASE_ERRORS, body_error, cancellation, backend_error)
+            _raise_body_and_release(body_error, release_error)
+
+    def _release_abandoned_holds(self) -> None:
+        # Runs from garbage collection, where no event loop may be running.
+        with contextlib.suppress(Exception):
+            # A thread-local lock never uses an executor, so an in-place release matches the loop's and also reaches
+            # threads whose loops it cannot schedule on.
+            if self._is_thread_local and not iscoroutinefunction(self._release):
+                self._release_without_loop()
+                return
+            try:
+                loop = asyncio.get_running_loop()
+            except RuntimeError:
+                # At interpreter exit daemon threads no longer run, so a loop running in one never runs the release.
+                if (loop := self._async_context.loop) is None or loop.is_closed() or sys.is_finalizing():
+                    self._release_without_loop()
+                    return
+                if not loop.is_running():  # pragma: no cover
+                    loop.run_until_complete(self.release(force=True))
+                    return
+                # Off the deadlock registry, a new lock in this task waits for the scheduled release instead of failing.
+                self._drop_registry_entry()
+                # The stored loop runs in another thread, and only its own thread may create tasks on it.
+                pending = asyncio.run_coroutine_threadsafe(self.release(force=True), loop)
+            else:
+                self._drop_registry_entry()
+                pending = loop.create_task(self.release(force=True))
+            # The loop keeps only a weak reference to a task, so hold one until the release finishes.
+            _FINALIZER_RELEASES.add(pending)
+            pending.add_done_callback(self._settle_finalizer_release)
+
+    def _settle_finalizer_release(self, pending: asyncio.Task[None] | futures.Future[None]) -> None:
+        _FINALIZER_RELEASES.discard(pending)
+        # Nothing awaits this release, so a failure or cancellation falls back to the sync release here.
+        with contextlib.suppress(asyncio.CancelledError, futures.CancelledError):
+            if pending.exception() is None:
+                return
+        with contextlib.suppress(Exception):
+            self._release_without_loop()
+
+    def _release_without_loop(self) -> None:
+        # No loop can run a release here, so call a sync backend directly as BaseFileLock.__del__ does; a coroutine
+        # backend cannot run and keeps its lock.
+        if iscoroutinefunction(self._release):
+            return
+        if self.is_locked:
+            try:
+                self._release_with_fork_tracking()
+            finally:
+                self._commit_release_if_released()
+        # A thread-local lock also holds for the threads that ran its loops, and nothing else releases those now.
+        self._release_thread_holds(exited_only=False)
+
+
+def _new_transition_gate() -> _AsyncTransitionGate:
+    # Called per context rather than passed as the factory, so the lazy import resolves on first use, not at import.
+    return _AsyncTransitionGate()
+
+
+@dataclass
+class AsyncFileLockContext(FileLockContext):
+    """A dataclass which holds the context for a ``BaseAsyncFileLock`` object."""
+
+    #: Whether run in executor
+    run_in_executor: bool = True
+
+    #: The executor
+    executor: futures.Executor | None = None
+
+    #: The loop
+    loop: asyncio.AbstractEventLoop | None = None
+
+    #: Serializes the tasks that transition this context. An acquire keeps it while it polls, so a thread-local lock
+    #: needs one per thread. A thread waiting for the lock must not keep the thread that holds it from releasing.
+    transition_gate: _AsyncTransitionGate = field(default_factory=_new_transition_gate)
+
+
+class AsyncThreadLocalFileContext(AsyncFileLockContext, ThreadLocalFileContext):
+    """A thread local version of the ``FileLockContext`` class."""
+
+    # threading.local runs __init__ again with these arguments the first time each thread touches the context.
+    def __init__(  # ruff:ignore[too-many-arguments]  # mirrors the AsyncFileLockContext fields set at construction
+        self,
+        *,
+        lock_file: str,
+        timeout: float,
+        mode: int,
+        blocking: bool,
+        poll_interval: float,
+        lifetime: float | None = None,
+        run_in_executor: bool = True,
+        executor: futures.Executor | None = None,
+        loop: asyncio.AbstractEventLoop | None = None,
+    ) -> None:
+        self.current = AsyncFileLockContext(
+            lock_file=lock_file,
+            timeout=timeout,
+            mode=mode,
+            blocking=blocking,
+            poll_interval=poll_interval,
+            lifetime=lifetime,
+            run_in_executor=run_in_executor,
+            executor=executor,
+            loop=loop,
+        )
+
+
+for _field in fields(AsyncFileLockContext):
+    setattr(AsyncThreadLocalFileContext, _field.name, _delegate_to_current(_field.name))
+
+
+class AsyncAcquireReturnProxy:
+    """A context-aware object that will release the lock file when exiting."""
+
+    def __init__(self, lock: BaseAsyncFileLock) -> None:  # ruff:ignore[undocumented-public-init]  # trivial release-on-exit proxy
+        self.lock = lock
+
+    async def __aenter__(self) -> BaseAsyncFileLock:  # ruff:ignore[undocumented-magic-method]  # returns the wrapped lock
+        return self.lock
+
+    async def __aexit__(  # ruff:ignore[undocumented-magic-method]  # releases the wrapped lock on exit
+        self,
+        exc_type: type[BaseException] | None,
+        exc_value: BaseException | None,
+        traceback: TracebackType | None,
+    ) -> None:
+        await self.lock._release_in_context(exc_value)  # ruff:ignore[private-member-access]  # releases the wrapped lock's context
+
+
+class AsyncSoftFileLock(SoftFileLock, BaseAsyncFileLock):
+    """Simply watches the existence of the lock file."""
+
+    _lifetime_replacements: tuple[str, str] | None = ("AsyncStrictSoftFileLock", "AsyncSoftFileLease")
+
+
+class AsyncStrictSoftFileLock(StrictSoftFileLock, BaseAsyncFileLock):
+    """Run strict owner-claim locking without blocking the event loop."""
+
+
+class AsyncSoftFileLease(SoftFileLease, BaseAsyncFileLock):
+    """Existence lock whose claim expires, so a peer may take it while the previous holder still runs."""
+
+
+class AsyncUnixFileLock(UnixFileLock, BaseAsyncFileLock):
+    """Uses the :func:`fcntl.flock` to hard lock the lock file on unix systems."""
+
+
+class AsyncWindowsFileLock(WindowsFileLock, BaseAsyncFileLock):
+    """Uses ``LockFileEx`` to hard lock a byte range of the lock file on Windows systems."""
+
+
+__all__ = [
+    "AsyncAcquireReturnProxy",
+    "AsyncSoftFileLease",
+    "AsyncSoftFileLock",
+    "AsyncStrictSoftFileLock",
+    "AsyncUnixFileLock",
+    "AsyncWindowsFileLock",
+    "BaseAsyncFileLock",
+]
+
+
+def __dir__() -> list[str]:
+    # Hide the sync bases and helpers imported at top level.
+    return list(__all__)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/version.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/version.py
new file mode 100644
index 0000000000000000000000000000000000000000..e4b292007e51eb25f14c4c0472451059b98ceb9a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/filelock/version.py
@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '4.2.4'
+__version_tuple__ = version_tuple = (4, 2, 4)
+
+__commit_id__ = commit_id = None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..492ec37aa4976eaa6b21bbed40bd70b67dfb1014
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/METADATA
@@ -0,0 +1,258 @@
+Metadata-Version: 2.5
+Name: fsspec
+Version: 2026.9.0
+Summary: File-system specification
+Project-URL: Changelog, https://filesystem-spec.readthedocs.io/en/latest/changelog.html
+Project-URL: Documentation, https://filesystem-spec.readthedocs.io/en/latest/
+Project-URL: Homepage, https://github.com/fsspec/filesystem_spec
+Maintainer-email: Martin Durant <mdurant@anaconda.com>
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: file
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Provides-Extra: abfs
+Requires-Dist: adlfs; extra == 'abfs'
+Provides-Extra: adl
+Requires-Dist: adlfs; extra == 'adl'
+Provides-Extra: arrow
+Requires-Dist: pyarrow>=1; extra == 'arrow'
+Provides-Extra: dask
+Requires-Dist: dask; extra == 'dask'
+Requires-Dist: distributed; extra == 'dask'
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: doc
+Requires-Dist: numpydoc; extra == 'doc'
+Requires-Dist: sphinx; extra == 'doc'
+Requires-Dist: sphinx-design; extra == 'doc'
+Requires-Dist: sphinx-rtd-theme; extra == 'doc'
+Requires-Dist: yarl; extra == 'doc'
+Provides-Extra: dropbox
+Requires-Dist: dropbox; extra == 'dropbox'
+Requires-Dist: dropboxdrivefs; extra == 'dropbox'
+Requires-Dist: requests; extra == 'dropbox'
+Provides-Extra: entrypoints
+Provides-Extra: full
+Requires-Dist: adlfs; extra == 'full'
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'full'
+Requires-Dist: dask; extra == 'full'
+Requires-Dist: distributed; extra == 'full'
+Requires-Dist: dropbox; extra == 'full'
+Requires-Dist: dropboxdrivefs; extra == 'full'
+Requires-Dist: fusepy; extra == 'full'
+Requires-Dist: gcsfs>=2026.4.0; extra == 'full'
+Requires-Dist: libarchive-c; extra == 'full'
+Requires-Dist: ocifs; extra == 'full'
+Requires-Dist: panel; extra == 'full'
+Requires-Dist: paramiko; extra == 'full'
+Requires-Dist: pyarrow>=1; extra == 'full'
+Requires-Dist: pygit2; extra == 'full'
+Requires-Dist: requests; extra == 'full'
+Requires-Dist: s3fs>=2026.6.0; extra == 'full'
+Requires-Dist: smbprotocol; extra == 'full'
+Requires-Dist: tqdm; extra == 'full'
+Provides-Extra: fuse
+Requires-Dist: fusepy; extra == 'fuse'
+Provides-Extra: gcs
+Requires-Dist: gcsfs>=2026.4.0; extra == 'gcs'
+Provides-Extra: git
+Requires-Dist: pygit2; extra == 'git'
+Provides-Extra: github
+Requires-Dist: requests; extra == 'github'
+Provides-Extra: gs
+Requires-Dist: gcsfs>=2026.4.0; extra == 'gs'
+Provides-Extra: gui
+Requires-Dist: panel; extra == 'gui'
+Provides-Extra: hdfs
+Requires-Dist: pyarrow>=1; extra == 'hdfs'
+Provides-Extra: http
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'http'
+Provides-Extra: libarchive
+Requires-Dist: libarchive-c; extra == 'libarchive'
+Provides-Extra: oci
+Requires-Dist: ocifs; extra == 'oci'
+Provides-Extra: s3
+Requires-Dist: s3fs>=2026.6.0; extra == 's3'
+Provides-Extra: sftp
+Requires-Dist: paramiko; extra == 'sftp'
+Provides-Extra: smb
+Requires-Dist: smbprotocol; extra == 'smb'
+Provides-Extra: ssh
+Requires-Dist: paramiko; extra == 'ssh'
+Provides-Extra: test
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'test'
+Requires-Dist: numpy; extra == 'test'
+Requires-Dist: pytest; extra == 'test'
+Requires-Dist: pytest-asyncio!=0.22.0; extra == 'test'
+Requires-Dist: pytest-benchmark; extra == 'test'
+Requires-Dist: pytest-cov; extra == 'test'
+Requires-Dist: pytest-mock; extra == 'test'
+Requires-Dist: pytest-recording; extra == 'test'
+Requires-Dist: pytest-rerunfailures; extra == 'test'
+Requires-Dist: requests; extra == 'test'
+Provides-Extra: test-downstream
+Requires-Dist: aiobotocore<3.0.0,>=2.5.4; extra == 'test-downstream'
+Requires-Dist: dask[dataframe,test]; extra == 'test-downstream'
+Requires-Dist: moto[server]<5,>4; extra == 'test-downstream'
+Requires-Dist: pytest-timeout; extra == 'test-downstream'
+Requires-Dist: xarray; extra == 'test-downstream'
+Requires-Dist: zarr; extra == 'test-downstream'
+Provides-Extra: test-full
+Requires-Dist: adlfs; extra == 'test-full'
+Requires-Dist: aiohttp!=4.0.0a0,!=4.0.0a1; extra == 'test-full'
+Requires-Dist: backports-zstd; (python_version < '3.14') and extra == 'test-full'
+Requires-Dist: cloudpickle; extra == 'test-full'
+Requires-Dist: dask; extra == 'test-full'
+Requires-Dist: distributed; extra == 'test-full'
+Requires-Dist: dropbox; extra == 'test-full'
+Requires-Dist: dropboxdrivefs; extra == 'test-full'
+Requires-Dist: fastparquet; extra == 'test-full'
+Requires-Dist: fusepy; extra == 'test-full'
+Requires-Dist: gcsfs>=2026.4.0; extra == 'test-full'
+Requires-Dist: jinja2; extra == 'test-full'
+Requires-Dist: kerchunk; extra == 'test-full'
+Requires-Dist: libarchive-c; extra == 'test-full'
+Requires-Dist: lz4; extra == 'test-full'
+Requires-Dist: notebook; extra == 'test-full'
+Requires-Dist: numpy; extra == 'test-full'
+Requires-Dist: ocifs; extra == 'test-full'
+Requires-Dist: pandas<3.0.0; extra == 'test-full'
+Requires-Dist: panel; extra == 'test-full'
+Requires-Dist: paramiko; extra == 'test-full'
+Requires-Dist: pyarrow>=1; extra == 'test-full'
+Requires-Dist: pyftpdlib; extra == 'test-full'
+Requires-Dist: pygit2; extra == 'test-full'
+Requires-Dist: pytest; extra == 'test-full'
+Requires-Dist: pytest-asyncio!=0.22.0; extra == 'test-full'
+Requires-Dist: pytest-benchmark; extra == 'test-full'
+Requires-Dist: pytest-cov; extra == 'test-full'
+Requires-Dist: pytest-mock; extra == 'test-full'
+Requires-Dist: pytest-recording; extra == 'test-full'
+Requires-Dist: pytest-rerunfailures; extra == 'test-full'
+Requires-Dist: python-snappy; extra == 'test-full'
+Requires-Dist: requests; extra == 'test-full'
+Requires-Dist: s3fs>=2026.6.0; extra == 'test-full'
+Requires-Dist: smbprotocol; extra == 'test-full'
+Requires-Dist: tqdm; extra == 'test-full'
+Requires-Dist: urllib3; extra == 'test-full'
+Requires-Dist: zarr<3.2.0; extra == 'test-full'
+Requires-Dist: zstandard; (python_version < '3.14') and extra == 'test-full'
+Provides-Extra: tqdm
+Requires-Dist: tqdm; extra == 'tqdm'
+Description-Content-Type: text/markdown
+
+# filesystem_spec
+
+[![PyPI version](https://badge.fury.io/py/fsspec.svg)](https://pypi.python.org/pypi/fsspec/)
+[![Anaconda-Server Badge](https://anaconda.org/conda-forge/fsspec/badges/version.svg)](https://anaconda.org/conda-forge/fsspec)
+![Build](https://github.com/fsspec/filesystem_spec/workflows/CI/badge.svg)
+[![Docs](https://readthedocs.org/projects/filesystem-spec/badge/?version=latest)](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+A specification for pythonic filesystems.
+
+## Install
+
+```bash
+pip install fsspec
+```
+
+would install the base fsspec. Various optionally supported features might require specification of custom
+extra require, e.g. `pip install fsspec[ssh]` will install dependencies for `ssh` backends support.
+Use `pip install fsspec[full]` for installation of all known extra dependencies.
+
+Up-to-date package also provided through conda-forge distribution:
+
+```bash
+conda install -c conda-forge fsspec
+```
+
+
+## Purpose
+
+To produce a template or specification for a file-system interface, that specific implementations should follow,
+so that applications making use of them can rely on a common behaviour and not have to worry about the specific
+internal implementation decisions with any given backend. Many such implementations are included in this package,
+or in sister projects such as `s3fs` and `gcsfs`.
+
+In addition, if this is well-designed, then additional functionality, such as a key-value store or FUSE
+mounting of the file-system implementation may be available for all implementations "for free".
+
+## Documentation
+
+Please refer to [RTD](https://filesystem-spec.readthedocs.io/en/latest/?badge=latest)
+
+## Develop
+
+fsspec uses GitHub Actions for CI. Environment files can be found
+in the "ci/" directory. Note that the main environment is called "py38",
+but it is expected that the version of python installed be adjustable at
+CI runtime. For local use, pick a version suitable for you.
+
+```bash
+# For a new environment (mamba / conda).
+mamba create -n fsspec -c conda-forge  python=3.10 -y
+conda activate fsspec
+
+# Standard dev install with docs and tests.
+pip install -e ".[dev,doc,test]"
+
+# Full tests except for downstream
+pip install s3fs
+pip uninstall s3fs
+pip install -e .[dev,doc,test_full]
+pip install s3fs --no-deps
+pytest -v
+
+# Downstream tests.
+sh install_s3fs.sh
+# Windows powershell.
+install_s3fs.sh
+```
+
+### Testing
+
+Tests can be run in the dev environment, if activated, via ``pytest fsspec``.
+
+The full fsspec suite requires a system-level docker, docker-compose, and fuse
+installation. If only making changes to one backend implementation, it is
+not generally necessary to run all tests locally.
+
+It is expected that contributors ensure that any change to fsspec does not
+cause issues or regressions for either other fsspec-related packages such
+as gcsfs and s3fs, nor for downstream users of fsspec. The "downstream" CI
+run and corresponding environment file run a set of tests from the dask
+test suite, and very minimal tests against pandas and zarr from the
+test_downstream.py module in this repo.
+
+### Code Formatting
+
+fsspec uses [Black](https://black.readthedocs.io/en/stable) to ensure
+a consistent code format throughout the project.
+Run ``black fsspec`` from the root of the filesystem_spec repository to
+auto-format your code. Additionally, many editors have plugins that will apply
+``black`` as you edit files. ``black`` is included in the ``tox`` environments.
+
+Optionally, you may wish to setup [pre-commit hooks](https://pre-commit.com) to
+automatically run ``black`` when you make a git commit.
+Run ``pre-commit install --install-hooks`` from the root of the
+filesystem_spec repository to setup pre-commit hooks. ``black`` will now be run
+before you commit, reformatting any changed files. You can format without
+committing via ``pre-commit run`` or skip these checks with ``git commit
+--no-verify``.
+
+## Support
+
+Work on this repository is supported in part by:
+
+"Anaconda, Inc. - Advancing AI through open source."
+
+<a href="https://anaconda.com/"><img src="https://camo.githubusercontent.com/b8555ef2222598ed37ce38ac86955febbd25de7619931bb7dd3c58432181d3b6/68747470733a2f2f626565776172652e6f72672f636f6d6d756e6974792f6d656d626572732f616e61636f6e64612f616e61636f6e64612d6c617267652e706e67" alt="anaconda logo" width="40%"/></a>
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..e2593dfe1e80e042a925e3f69d29a80951adca0e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/RECORD
@@ -0,0 +1,121 @@
+fsspec-2026.9.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+fsspec-2026.9.0.dist-info/METADATA,sha256=aPWiYnZ1EGOOmxkzsUk_K6rclhb-HmlvYq7dWcjAo3w,10609
+fsspec-2026.9.0.dist-info/RECORD,,
+fsspec-2026.9.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+fsspec-2026.9.0.dist-info/licenses/LICENSE,sha256=LcNUls5TpzB5FcAIqESq1T53K0mzTN0ARFBnaRQH7JQ,1513
+fsspec/__init__.py,sha256=xFcoHBD17fc5KamKUQAIA0rePGjLqIN1WBAd9NAoAi8,2111
+fsspec/__pycache__/__init__.cpython-311.pyc,,
+fsspec/__pycache__/_version.cpython-311.pyc,,
+fsspec/__pycache__/archive.cpython-311.pyc,,
+fsspec/__pycache__/asyn.cpython-311.pyc,,
+fsspec/__pycache__/caching.cpython-311.pyc,,
+fsspec/__pycache__/callbacks.cpython-311.pyc,,
+fsspec/__pycache__/compression.cpython-311.pyc,,
+fsspec/__pycache__/config.cpython-311.pyc,,
+fsspec/__pycache__/conftest.cpython-311.pyc,,
+fsspec/__pycache__/core.cpython-311.pyc,,
+fsspec/__pycache__/dircache.cpython-311.pyc,,
+fsspec/__pycache__/exceptions.cpython-311.pyc,,
+fsspec/__pycache__/fuse.cpython-311.pyc,,
+fsspec/__pycache__/generic.cpython-311.pyc,,
+fsspec/__pycache__/gui.cpython-311.pyc,,
+fsspec/__pycache__/json.cpython-311.pyc,,
+fsspec/__pycache__/mapping.cpython-311.pyc,,
+fsspec/__pycache__/parquet.cpython-311.pyc,,
+fsspec/__pycache__/prefetcher.cpython-311.pyc,,
+fsspec/__pycache__/registry.cpython-311.pyc,,
+fsspec/__pycache__/spec.cpython-311.pyc,,
+fsspec/__pycache__/transaction.cpython-311.pyc,,
+fsspec/__pycache__/utils.cpython-311.pyc,,
+fsspec/_version.py,sha256=CFkLh48vGlx4uPc2-xnYbp3Hsx020MfNC44_iizaFTo,526
+fsspec/archive.py,sha256=9RsPnfI5c4WNDdcisBBEnaIXa48MJwgPknKQNm2kDsQ,2733
+fsspec/asyn.py,sha256=_KEgV7OLoRx8Uo1hCjnm0mrGVB00CMuCfMbKV6sZmDk,42244
+fsspec/caching.py,sha256=V_Hr1Ph5c4HFsIeVr81nRdjpn-mmzrSNQ0GR0bFYvY8,38542
+fsspec/callbacks.py,sha256=BDIwLzK6rr_0V5ch557fSzsivCElpdqhXr5dZ9Te-EE,9210
+fsspec/compression.py,sha256=3v_Fe39gzRRWfaeXpzNjAGPqgTzmETYRCo3qHVqD3po,5132
+fsspec/config.py,sha256=mHKzAgjXa_LwqtO_VoTJJ568VqwYkbK3gUp4J6JZJp4,4238
+fsspec/conftest.py,sha256=uWfm_Qs5alPRxOhRpDfQ0-1jqSJ54pni4y96IxOREXM,3446
+fsspec/core.py,sha256=m5jZWbTReNNV6MXFZJlKnFHH_IIqY9ReHrL9OyDt0nU,24428
+fsspec/dircache.py,sha256=YzogWJrhEastHU7vWz-cJiJ7sdtLXFXhEpInGKd4EcM,2717
+fsspec/exceptions.py,sha256=pauSLDMxzTJMOjvX1WEUK0cMyFkrFxpWJsyFywav7A8,331
+fsspec/fuse.py,sha256=Q-3NOOyLqBfYa4Db5E19z_ZY36zzYHtIs1mOUasItBQ,10177
+fsspec/generic.py,sha256=-LIADa9qRN79bfa3Hl9m3HaN6rlU2GNivawLNmybqxE,13752
+fsspec/gui.py,sha256=CQ7QsrTpaDlWSLNOpwNoJc7khOcYXIZxmrAJN9bHWQU,14002
+fsspec/implementations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fsspec/implementations/__pycache__/__init__.cpython-311.pyc,,
+fsspec/implementations/__pycache__/arrow.cpython-311.pyc,,
+fsspec/implementations/__pycache__/asyn_wrapper.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc,,
+fsspec/implementations/__pycache__/cached.cpython-311.pyc,,
+fsspec/implementations/__pycache__/chained.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dask.cpython-311.pyc,,
+fsspec/implementations/__pycache__/data.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dbfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/dirfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/ftp.cpython-311.pyc,,
+fsspec/implementations/__pycache__/gist.cpython-311.pyc,,
+fsspec/implementations/__pycache__/git.cpython-311.pyc,,
+fsspec/implementations/__pycache__/github.cpython-311.pyc,,
+fsspec/implementations/__pycache__/http.cpython-311.pyc,,
+fsspec/implementations/__pycache__/http_sync.cpython-311.pyc,,
+fsspec/implementations/__pycache__/jupyter.cpython-311.pyc,,
+fsspec/implementations/__pycache__/libarchive.cpython-311.pyc,,
+fsspec/implementations/__pycache__/local.cpython-311.pyc,,
+fsspec/implementations/__pycache__/memory.cpython-311.pyc,,
+fsspec/implementations/__pycache__/reference.cpython-311.pyc,,
+fsspec/implementations/__pycache__/sftp.cpython-311.pyc,,
+fsspec/implementations/__pycache__/smb.cpython-311.pyc,,
+fsspec/implementations/__pycache__/tar.cpython-311.pyc,,
+fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc,,
+fsspec/implementations/__pycache__/zip.cpython-311.pyc,,
+fsspec/implementations/arrow.py,sha256=NGtJ9yWBt5SPpvDPTo-p4ry2j0R9cOCTecd5oA6rxFo,9344
+fsspec/implementations/asyn_wrapper.py,sha256=IYrY--XM7GUz-5c3i_4FE7znTQogruyqsp7UhAKwZvk,4304
+fsspec/implementations/cache_mapper.py,sha256=W4wlxyPxZbSp9ItJ0pYRVBMh6bw9eFypgP6kUYuuiI4,2421
+fsspec/implementations/cache_metadata.py,sha256=EPhQV27lgPlYREYprDET1vcMed15pVNMit-Ta1ljoyE,7942
+fsspec/implementations/cached.py,sha256=c6ayv1S6JctBw1iiEDS29fytOU0vhi0fboeE2xcSzBY,38867
+fsspec/implementations/chained.py,sha256=iGivpNaHUFjB_ea0-HAPhcmm6CL8qnDf270PSj7JwuE,680
+fsspec/implementations/dask.py,sha256=CXZbJzIVOhKV8ILcxuy3bTvcacCueAbyQxmvAkbPkrk,4466
+fsspec/implementations/data.py,sha256=9tMcy1fyX1auvzFX2aANPK9CfPoarnxTCDLhX12usvs,2131
+fsspec/implementations/dbfs.py,sha256=yHuLUGNmQd5pUCt9vpXleQNpjOpIZZwVZA08YauQU4U,16249
+fsspec/implementations/dirfs.py,sha256=c8ulhykA0zL7-60tZeMS0VbtkKrCT6pImyooyAG14-Y,15120
+fsspec/implementations/ftp.py,sha256=S_y5XOv_QhBiYBw430qzFB5MfS9AzxNBOs3f87XehC0,13539
+fsspec/implementations/gist.py,sha256=Y6jTDrE-wuTwvpPyAQDuuOMBGxlajafKWoB1_yX6jdY,8528
+fsspec/implementations/git.py,sha256=qBDWMz5LNllPqVjr5jf_1FuNha4P5lyQI3IlhYg-wUE,3731
+fsspec/implementations/github.py,sha256=aCsZL8UvXZgdkcB1RUs3DdLeNrjLKcFsFYeQFDWbBFo,11653
+fsspec/implementations/http.py,sha256=1uWwxllOjPe8mQD54IrCYQJHU1YaAXh_cDmXBk-AoQ8,30894
+fsspec/implementations/http_sync.py,sha256=UmBqd938ebwVjYgVtzg-ysG3ZoGhIJw0wFtQAfxV3Aw,30332
+fsspec/implementations/jupyter.py,sha256=q1PlQ66AAswGFyr8MFKWyobaV2YekMWRtqENBDQtD28,4002
+fsspec/implementations/libarchive.py,sha256=SpIA1F-zf7kb2-VYUVuhMrXTBOhBxUXKgEW1RaAdDoA,7098
+fsspec/implementations/local.py,sha256=pvNJBrPx9LUX6h0eW-SAF_DU0do6TstAfn2kLAVWC_Y,17726
+fsspec/implementations/memory.py,sha256=8tvbep-bodi2Mgw33jOBVCvri024Y05PQkJK0w8KVdU,15956
+fsspec/implementations/reference.py,sha256=0p6uJjPU04PEekuUkJWI-yFKIVTQI8kLWe98hemvxEY,50997
+fsspec/implementations/sftp.py,sha256=a84flSX8eL7csJzUX1H66XXyBLdxesVHmgd325VVpEY,8864
+fsspec/implementations/smb.py,sha256=5fhu8h06nOLBPh2c48aT7WBRqh9cEcbIwtyu06wTjec,15236
+fsspec/implementations/tar.py,sha256=YWwcw_egHABzTgYSauaEgWkZ6_fQN6Ozh03sNISis3Q,5573
+fsspec/implementations/webhdfs.py,sha256=osF2m0nhDil6sbMzYW_4DZzhxF4ygtb59XDiybd9Fyg,17589
+fsspec/implementations/zip.py,sha256=6DJPdq01mIMc8CSnJpMs08LKRNGipFMqJPUC8rou1qU,6712
+fsspec/json.py,sha256=4EBZ-xOmRiyxmIqPIwxmDImosRQ7io7qBM2xjJPsEE4,3768
+fsspec/mapping.py,sha256=gLCwX6LZcw09s6qZUKLnc3gxm1JBtjE6hU70bE8pNmc,8537
+fsspec/parquet.py,sha256=0SzfswUTc2k5nAj7xZNYPPyvUkFNXznFRXXtBRhr-iE,20506
+fsspec/prefetcher.py,sha256=Yg_lWdSSP2eDvbQqv3p-Zajq2M1FeyoocIvVmFLXyXs,32611
+fsspec/registry.py,sha256=KeDNL9HOyHX_D4D4qQGAI-Y3DQhiLeUC1VK2I81NZaE,12344
+fsspec/spec.py,sha256=rdVOdEMNEWf4-fWsU0m-voESNPUFWJndo7SsHFuYYDs,80278
+fsspec/tests/abstract/__init__.py,sha256=V0-8FqQPfHlHZ3xomJ0hyWl6t1QvqsDnQFJYHeSTlEw,10197
+fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/common.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/get.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/mv.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/open.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/pipe.cpython-311.pyc,,
+fsspec/tests/abstract/__pycache__/put.cpython-311.pyc,,
+fsspec/tests/abstract/common.py,sha256=1GQwNo5AONzAnzZj0fWgn8NJPLXALehbsuGxS3FzWVU,4973
+fsspec/tests/abstract/copy.py,sha256=gU5-d97U3RSde35Vp4RxPY4rWwL744HiSrJ8IBOp9-8,19967
+fsspec/tests/abstract/get.py,sha256=vNR4HztvTR7Cj56AMo7_tx7TeYz1Jgr_2Wb8Lv-UiBY,20755
+fsspec/tests/abstract/mv.py,sha256=k8eUEBIrRrGMsBY5OOaDXdGnQUKGwDIfQyduB6YD3Ns,1982
+fsspec/tests/abstract/open.py,sha256=Fi2PBPYLbRqysF8cFm0rwnB41kMdQVYjq8cGyDXp3BU,329
+fsspec/tests/abstract/pipe.py,sha256=LFzIrLCB5GLXf9rzFKJmE8AdG7LQ_h4bJo70r8FLPqM,402
+fsspec/tests/abstract/put.py,sha256=7aih17OKB_IZZh1Mkq1eBDIjobhtMQmI8x-Pw-S_aZk,21201
+fsspec/transaction.py,sha256=bS1yQQPEgHlREQSBjw-1DrdqYn27MdctkA55E78nt9s,3392
+fsspec/utils.py,sha256=nTXWV9xEHo9L511ULkj8RDL-AfsGq4ClAVgfGa_Ws10,28458
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..8dd28d81996853c380eda64106114ad2bec0566c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.3
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..67590a5e5be5a5a2dde3fe53a7512e404a896c22
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec-2026.9.0.dist-info/licenses/LICENSE
@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2018, Martin Durant
+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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5de87eda16630e55f6a48eae3e145515c167d9cb
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__init__.py
@@ -0,0 +1,75 @@
+from . import caching
+from .callbacks import Callback
+from .compression import available_compressions
+from .core import get_fs_token_paths, open, open_files, open_local, url_to_fs
+from .exceptions import FSTimeoutError
+from .mapping import FSMap, get_mapper
+from .registry import (
+    available_protocols,
+    filesystem,
+    get_filesystem_class,
+    register_implementation,
+    registry,
+)
+from .spec import AbstractFileSystem
+
+try:
+    from ._version import __version__  # noqa: F401
+except ImportError:
+    __version__ = "unknown"
+
+__all__ = [
+    "AbstractFileSystem",
+    "FSTimeoutError",
+    "FSMap",
+    "filesystem",
+    "register_implementation",
+    "get_filesystem_class",
+    "get_fs_token_paths",
+    "get_mapper",
+    "open",
+    "open_files",
+    "open_local",
+    "registry",
+    "caching",
+    "Callback",
+    "available_protocols",
+    "available_compressions",
+    "url_to_fs",
+]
+
+
+def process_entries():
+    try:
+        from importlib.metadata import entry_points
+    except ImportError:
+        return
+    if entry_points is not None:
+        try:
+            eps = entry_points()
+        except TypeError:
+            pass  # importlib-metadata < 0.8
+        else:
+            if hasattr(eps, "select"):  # Python 3.10+ / importlib_metadata >= 3.9.0
+                specs = eps.select(group="fsspec.specs")
+            else:
+                specs = eps.get("fsspec.specs", [])
+            registered_names = {}
+            for spec in specs:
+                err_msg = f"Unable to load filesystem from {spec}"
+                name = spec.name
+                if name in registered_names:
+                    continue
+                registered_names[name] = True
+                register_implementation(
+                    name,
+                    spec.value.replace(":", "."),
+                    errtxt=err_msg,
+                    # We take our implementations as the ones to overload with if
+                    # for some reason we encounter some, may be the same, already
+                    # registered
+                    clobber=True,
+                )
+
+
+process_entries()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c591ae9482dcdd7fb41367e338c8a7cd0f49a7a4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..95d5e2d058034012e95ed8b39190e77fa3552c01
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/_version.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..acf9ee0e6643bf0e6ffd6fc4fabae11286836423
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/archive.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a4e5ca70dd4a93c43cb8ab8c63d03e7c2b93739
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/asyn.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c2a969a001b859e427271494feb47414506023e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/caching.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fab36c4075ee27ece53365c0fc22e026a9182620
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/callbacks.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..66a8939e5b082e19f7bfb24872150dad8502e9ba
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/compression.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..da002e77eda7be6e1a887d881562dd040e1ca686
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/config.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8c343f51901271722e5693f4c40ca0b879918386
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/conftest.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..94e7cb2182b8c5107ad9fed14af620100d78b931
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/core.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..af385a832808b0abb73ac06fabef421db3b811d0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/dircache.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c3596be04c61bfcdd1e485788a06a24ac2e2c951
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..410965f52578db382f16baf800887ba9acfb9745
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/fuse.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..72286ff3139b6dd1b0ae2bc918700ae1302f94ae
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/generic.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5fb10c65d957be9d4025d0ed04921e0253c891e8
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/gui.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/json.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/json.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..55ce818093459eeecc5b15edd8f0017b799f1ad4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/json.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..724a5a38faa927a2aaa163ca437c3c96d28a9bfb
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/mapping.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..343b5e3873d6751316db3585d18c2f131fda5de1
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/parquet.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/prefetcher.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/prefetcher.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6694bb03c10382d594e6d0c7c5b177dcc42d6bf2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/prefetcher.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2accd0302fda351d0c1971fa82096f2a876d7c37
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/registry.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6110034e6c1c5dde379f180c74048624fe5ad70d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/spec.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:260181ee0e85bc0e98fb89979e1f037281ce50868df16a8d60691e1b9a482b99
+size 104805
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd197903ba7cd40ff72f79f2ad732867e51c0c71
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/transaction.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b6fecb9b711800a642e14e5c66a4fe7fb95c96a2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/__pycache__/utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/_version.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..98754697aa15bf37be0e64540bdbbad03ea1e306
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/_version.py
@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '2026.9.0'
+__version_tuple__ = version_tuple = (2026, 9, 0)
+
+__commit_id__ = commit_id = None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/archive.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/archive.py
new file mode 100644
index 0000000000000000000000000000000000000000..7aa317fc5167edb4e79c9d077569b498bb6cd887
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/archive.py
@@ -0,0 +1,81 @@
+import operator
+
+from fsspec import AbstractFileSystem
+from fsspec.utils import tokenize
+
+
+class AbstractArchiveFileSystem(AbstractFileSystem):
+    """
+    A generic superclass for implementing Archive-based filesystems.
+
+    Currently, it is shared amongst
+    :class:`~fsspec.implementations.zip.ZipFileSystem`,
+    :class:`~fsspec.implementations.libarchive.LibArchiveFileSystem` and
+    :class:`~fsspec.implementations.tar.TarFileSystem`.
+    """
+
+    def __str__(self):
+        return f"<Archive-like object {type(self).__name__} at {id(self)}>"
+
+    __repr__ = __str__
+
+    def ukey(self, path):
+        return tokenize(path, self.fo, self.protocol)
+
+    def _all_dirnames(self, paths):
+        """Returns *all* directory names for each path in paths, including intermediate
+        ones.
+
+        Parameters
+        ----------
+        paths: Iterable of path strings
+        """
+        if len(paths) == 0:
+            return set()
+
+        dirnames = {self._parent(path) for path in paths} - {self.root_marker}
+        return dirnames | self._all_dirnames(dirnames)
+
+    def info(self, path, **kwargs):
+        self._get_dirs()
+        path = self._strip_protocol(path)
+        if path in {"", "/"} and self.dir_cache:
+            return {"name": "", "type": "directory", "size": 0}
+        if path in self.dir_cache:
+            return self.dir_cache[path]
+        elif path + "/" in self.dir_cache:
+            return self.dir_cache[path + "/"]
+        else:
+            raise FileNotFoundError(path)
+
+    def ls(self, path, detail=True, **kwargs):
+        self._get_dirs()
+        paths = {}
+        for p, f in self.dir_cache.items():
+            p = p.rstrip("/")
+            if "/" in p:
+                root = p.rsplit("/", 1)[0]
+            else:
+                root = ""
+            if root == path.rstrip("/"):
+                paths[p] = f
+            elif all(
+                (a == b)
+                for a, b in zip(path.split("/"), [""] + p.strip("/").split("/"))
+            ):
+                # root directory entry
+                ppath = p.rstrip("/").split("/", 1)[0]
+                if ppath not in paths:
+                    out = {"name": ppath, "size": 0, "type": "directory"}
+                    paths[ppath] = out
+        if not paths and path.strip("/"):
+            # Nothing is listed under ``path``, so it is a file, an empty
+            # directory or missing; ``info`` raises FileNotFoundError for the last.
+            info = self.info(path)
+            if info["type"] != "directory":
+                paths[info["name"]] = info
+        if detail:
+            out = sorted(paths.values(), key=operator.itemgetter("name"))
+            return out
+        else:
+            return sorted(paths)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/asyn.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/asyn.py
new file mode 100644
index 0000000000000000000000000000000000000000..faf194685c308d45b03f403f19a00079a8fe26e1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/asyn.py
@@ -0,0 +1,1277 @@
+import asyncio
+import asyncio.events
+import concurrent.futures
+import functools
+import inspect
+import io
+import logging
+import numbers
+import os
+import re
+import sys
+import threading
+from collections.abc import Iterable
+from glob import has_magic
+from typing import TYPE_CHECKING
+
+from .callbacks import DEFAULT_CALLBACK
+from .exceptions import FSTimeoutError
+from .implementations.local import LocalFileSystem, make_path_posix, trailing_sep
+from .spec import AbstractBufferedFile, AbstractFileSystem
+from .utils import check_contained, glob_translate, is_exception, other_paths
+
+private = re.compile("_[^_]")
+iothread = [None]  # dedicated fsspec IO thread
+loop = [None]  # global event loop for any non-async instance
+_lock = None  # global lock placeholder
+get_running_loop = asyncio.get_running_loop
+
+
+def get_lock():
+    """Allocate or return a threading lock.
+
+    The lock is allocated on first use to allow setting one lock per forked process.
+    """
+    global _lock
+    if not _lock:
+        _lock = threading.Lock()
+    return _lock
+
+
+def reset_lock():
+    """Reset the global lock.
+
+    This should be called only on the init of a forked process to reset the lock to
+    None, enabling the new forked process to get a new lock.
+    """
+    global _lock
+
+    iothread[0] = None
+    loop[0] = None
+    _lock = None
+
+
+async def _runner(event, coro, result, timeout=None):
+    timeout = timeout if timeout else None  # convert 0 or 0.0 to None
+    if timeout is not None:
+        coro = asyncio.wait_for(coro, timeout=timeout)
+    try:
+        result[0] = await coro
+    except Exception as ex:
+        result[0] = ex
+    finally:
+        event.set()
+
+
+def sync(loop, func, *args, timeout=None, **kwargs):
+    """
+    Make loop run coroutine until it returns. Runs in other thread
+
+    Examples
+    --------
+    >>> fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args,
+                         timeout=timeout, **kwargs)
+    """
+    timeout = timeout if timeout else None  # convert 0 or 0.0 to None
+    # NB: if the loop is not running *yet*, it is OK to submit work
+    # and we will wait for it
+    if loop is None or loop.is_closed():
+        raise RuntimeError("Loop is not running")
+    try:
+        loop0 = asyncio.events.get_running_loop()
+        if loop0 is loop:
+            raise NotImplementedError("Calling sync() from within a running loop")
+    except NotImplementedError:
+        raise
+    except RuntimeError:
+        pass
+    coro = func(*args, **kwargs)
+    result = [None]
+    event = threading.Event()
+    asyncio.run_coroutine_threadsafe(_runner(event, coro, result, timeout), loop)
+    while True:
+        # this loops allows thread to get interrupted
+        if event.wait(1):
+            break
+        if timeout is not None:
+            timeout -= 1
+            if timeout < 0:
+                raise FSTimeoutError
+
+    return_result = result[0]
+    if isinstance(return_result, asyncio.TimeoutError):
+        # suppress asyncio.TimeoutError, raise FSTimeoutError
+        raise FSTimeoutError from return_result
+    elif isinstance(return_result, BaseException):
+        raise return_result
+    else:
+        return return_result
+
+
+_deferred_close_tasks = set()
+_deferred_close_lock = threading.Lock()
+
+
+def _on_loop_thread(loop):
+    """Returns True if the current thread is servicing the given event loop."""
+    if loop is None:
+        return False
+    try:
+        return asyncio.get_running_loop() is loop
+    except RuntimeError:
+        return False
+
+
+def _defer_task(
+    loop,
+    coro,
+    description="deferred task",
+    logger=None,
+    log_level=logging.WARNING,
+):
+    """Schedules a coroutine as a tracked background task on ``loop``.
+
+    Retains a strong reference in ``_deferred_close_tasks`` until completion to
+    prevent asyncio garbage collection from discarding pending tasks mid-flight,
+    and ensures unhandled task exceptions are retrieved and logged.
+    """
+    task = loop.create_task(coro)
+    with _deferred_close_lock:
+        _deferred_close_tasks.add(task)
+
+    def _on_done(t):
+        with _deferred_close_lock:
+            _deferred_close_tasks.discard(t)
+        if not t.cancelled():
+            exc = t.exception()
+            if exc:
+                log = logger or logging.getLogger("fsspec.asyn")
+                log.log(
+                    log_level,
+                    "%s failed during asynchronous execution: %s",
+                    description,
+                    exc,
+                    exc_info=exc,
+                )
+
+    task.add_done_callback(_on_done)
+    return task
+
+
+def sync_teardown(
+    loop,
+    func_or_coro,
+    *args,
+    timeout=None,
+    description="teardown",
+    **kwargs,
+):
+    """Safely runs an async teardown coroutine on ``loop`` from synchronous context.
+
+    Schedules via :func:`asyncio.run_coroutine_threadsafe` or defers on the loop
+    thread to prevent deadlocks.
+    """
+    coro = func_or_coro(*args, **kwargs) if callable(func_or_coro) else func_or_coro
+    if not asyncio.iscoroutine(coro):
+        return
+
+    if sys.is_finalizing():
+        coro.close()
+        return
+
+    if loop is None or not loop.is_running() or loop.is_closed():
+        coro.close()
+        raise RuntimeError(f"Skipping {description}: no usable IO loop available.")
+
+    if _on_loop_thread(loop):
+        _defer_task(loop, coro, description=description, log_level=logging.ERROR)
+        return
+
+    try:
+        future = asyncio.run_coroutine_threadsafe(coro, loop)
+    except RuntimeError:
+        coro.close()
+        raise RuntimeError(f"Skipping {description}: event loop is closed.") from None
+
+    if timeout is not None and timeout <= 0:
+        return
+
+    try:
+        return future.result(timeout)
+    except concurrent.futures.TimeoutError:
+        raise FSTimeoutError(
+            f"{description} did not complete within {timeout}s."
+        ) from None
+
+
+def sync_wrapper(func, obj=None):
+    """Given a function, make so can be called in blocking contexts
+
+    Leave obj=None if defining within a class. Pass the instance if attaching
+    as an attribute of the instance.
+    """
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        self = obj or args[0]
+        return sync(self.loop, func, *args, **kwargs)
+
+    return wrapper
+
+
+def async_gen_wrapper(func, obj=None):
+    """Given a async generator, make so can be called in blocking contexts"""
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        self = obj or args[0]
+        gen = func(*args, **kwargs)
+        while True:
+            try:
+                yield sync(self.loop, gen.__anext__)
+            except StopAsyncIteration:
+                break
+
+    return wrapper
+
+
+def get_loop():
+    """Create or return the default fsspec IO loop
+
+    The loop will be running on a separate thread.
+    """
+    if loop[0] is None:
+        with get_lock():
+            # repeat the check just in case the loop got filled between the
+            # previous two calls from another thread
+            if loop[0] is None:
+                loop[0] = asyncio.new_event_loop()
+                th = threading.Thread(target=loop[0].run_forever, name="fsspecIO")
+                th.daemon = True
+                th.start()
+                iothread[0] = th
+    return loop[0]
+
+
+def reset_after_fork():
+    global lock
+    loop[0] = None
+    iothread[0] = None
+    lock = None
+
+
+if hasattr(os, "register_at_fork"):
+    # should be posix; this will do nothing for spawn or forkserver subprocesses
+    os.register_at_fork(after_in_child=reset_after_fork)
+
+
+if TYPE_CHECKING:
+    import resource
+
+    ResourceError = resource.error
+else:
+    try:
+        import resource
+    except ImportError:
+        resource = None
+        ResourceError = OSError
+    else:
+        ResourceError = getattr(resource, "error", OSError)
+
+_DEFAULT_BATCH_SIZE = 128
+_NOFILES_DEFAULT_BATCH_SIZE = 1280
+
+
+def _get_batch_size(nofiles=False):
+    from fsspec.config import conf
+
+    if nofiles:
+        if "nofiles_gather_batch_size" in conf:
+            return conf["nofiles_gather_batch_size"]
+    else:
+        if "gather_batch_size" in conf:
+            return conf["gather_batch_size"]
+    if nofiles:
+        return _NOFILES_DEFAULT_BATCH_SIZE
+    if resource is None:
+        return _DEFAULT_BATCH_SIZE
+
+    try:
+        soft_limit, _ = resource.getrlimit(resource.RLIMIT_NOFILE)
+    except (ImportError, ValueError, ResourceError):
+        return _DEFAULT_BATCH_SIZE
+
+    if soft_limit == resource.RLIM_INFINITY:
+        return -1
+    else:
+        return soft_limit // 8
+
+
+def running_async() -> bool:
+    """Being executed by an event loop?"""
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
+
+async def _run_coros_in_chunks(
+    coros,
+    batch_size=None,
+    callback=DEFAULT_CALLBACK,
+    timeout=None,
+    return_exceptions=False,
+    nofiles=False,
+):
+    """Run the given coroutines in  chunks.
+
+    Parameters
+    ----------
+    coros: list of coroutines to run
+    batch_size: int or None
+        Number of coroutines to submit/wait on simultaneously.
+        If -1, then it will not be any throttling. If
+        None, it will be inferred from _get_batch_size()
+    callback: fsspec.callbacks.Callback instance
+        Gets a relative_update when each coroutine completes
+    timeout: number or None
+        If given, each coroutine times out after this time. Note that, since
+        there are multiple batches, the total run time of this function will in
+        general be longer
+    return_exceptions: bool
+        Same meaning as in asyncio.gather
+    nofiles: bool
+        If inferring the batch_size, does this operation involve local files?
+        If yes, you normally expect smaller batches.
+    """
+
+    if batch_size is None:
+        batch_size = _get_batch_size(nofiles=nofiles)
+
+    if batch_size == -1:
+        batch_size = len(coros)
+    elif batch_size <= 0:
+        raise ValueError
+
+    async def _run_coro(coro, i):
+        try:
+            return await asyncio.wait_for(coro, timeout=timeout), i
+        except Exception as e:
+            if not return_exceptions:
+                raise
+            return e, i
+        finally:
+            callback.relative_update(1)
+
+    i = 0
+    n = len(coros)
+    results = [None] * n
+    pending = set()
+
+    while pending or i < n:
+        while len(pending) < batch_size and i < n:
+            pending.add(asyncio.ensure_future(_run_coro(coros[i], i)))
+            i += 1
+
+        if not pending:
+            break
+
+        done, pending = await asyncio.wait(pending, return_when=asyncio.FIRST_COMPLETED)
+        first_exc = None
+        while done:
+            task = done.pop()
+            try:
+                result, k = await task
+                results[k] = result
+            except Exception as exc:
+                if first_exc is None:
+                    first_exc = exc
+
+        if first_exc is not None:
+            for task in pending:
+                task.cancel()
+            if pending:
+                await asyncio.gather(*pending, return_exceptions=True)
+            raise first_exc
+
+    return results
+
+
+# these methods should be implemented as async by any async-able backend
+async_methods = [
+    "_ls",
+    "_cat_file",
+    "_get_file",
+    "_put_file",
+    "_rm_file",
+    "_cp_file",
+    "_pipe_file",
+    "_expand_path",
+    "_info",
+    "_isfile",
+    "_isdir",
+    "_exists",
+    "_walk",
+    "_glob",
+    "_find",
+    "_du",
+    "_size",
+    "_mkdir",
+    "_makedirs",
+]
+
+
+class AsyncFileSystem(AbstractFileSystem):
+    """Async file operations, default implementations
+
+    Passes bulk operations to asyncio.gather for concurrent operation.
+
+    Implementations that have concurrent batch operations and/or async methods
+    should inherit from this class instead of AbstractFileSystem. Docstrings are
+    copied from the un-underscored method in AbstractFileSystem, if not given.
+    """
+
+    # note that methods do not have docstring here; they will be copied
+    # for _* methods and inferred for overridden methods.
+
+    async_impl = True
+    mirror_sync_methods = True
+    disable_throttling = False
+
+    def __init__(self, *args, asynchronous=False, loop=None, batch_size=None, **kwargs):
+        self.asynchronous = asynchronous
+        self._pid = os.getpid()
+        if not asynchronous:
+            self._loop = loop or get_loop()
+        else:
+            self._loop = None
+        self.batch_size = batch_size
+        super().__init__(*args, **kwargs)
+
+    @property
+    def loop(self):
+        if self._pid != os.getpid():
+            raise RuntimeError("This class is not fork-safe")
+        return self._loop
+
+    async def _rm_file(self, path, **kwargs):
+        if (
+            inspect.iscoroutinefunction(self._rm)
+            and type(self)._rm is not AsyncFileSystem._rm
+        ):
+            return await self._rm(path, recursive=False, batch_size=1, **kwargs)
+        raise NotImplementedError
+
+    async def _rm(
+        self, path, recursive=False, batch_size=None, maxdepth=None, **kwargs
+    ):
+        # TODO: implement on_error
+        batch_size = batch_size or self.batch_size
+        path = await self._expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        return await _run_coros_in_chunks(
+            [self._rm_file(p, **kwargs) for p in reversed(path)],
+            batch_size=batch_size,
+            nofiles=True,
+        )
+
+    async def _cp_file(self, path1, path2, **kwargs):
+        raise NotImplementedError
+
+    async def _mv_file(self, path1, path2):
+        await self._cp_file(path1, path2)
+        await self._rm_file(path1)
+
+    async def _copy(
+        self,
+        path1,
+        path2,
+        recursive=False,
+        on_error=None,
+        maxdepth=None,
+        batch_size=None,
+        **kwargs,
+    ):
+        if on_error is None and recursive:
+            on_error = "ignore"
+        elif on_error is None:
+            on_error = "raise"
+
+        if isinstance(path1, list) and isinstance(path2, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            paths1 = path1
+            paths2 = path2
+        else:
+            source_is_str = isinstance(path1, str)
+            paths1 = await self._expand_path(
+                path1, maxdepth=maxdepth, recursive=recursive
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                paths1 = [
+                    p for p in paths1 if not (trailing_sep(p) or await self._isdir(p))
+                ]
+                if not paths1:
+                    return
+
+            source_is_file = len(paths1) == 1
+            dest_is_dir = isinstance(path2, str) and (
+                trailing_sep(path2) or await self._isdir(path2)
+            )
+
+            exists = source_is_str and (
+                (has_magic(path1) and source_is_file)
+                or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+            )
+            paths2 = other_paths(
+                paths1,
+                path2,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        batch_size = batch_size or self.batch_size
+        coros = [self._cp_file(p1, p2, **kwargs) for p1, p2 in zip(paths1, paths2)]
+        result = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, return_exceptions=True, nofiles=True
+        )
+
+        for ex in filter(is_exception, result):
+            if on_error == "ignore" and isinstance(ex, FileNotFoundError):
+                continue
+            raise ex
+
+    async def _pipe_file(self, path, value, mode="overwrite", **kwargs):
+        raise NotImplementedError
+
+    async def _pipe(self, path, value=None, batch_size=None, **kwargs):
+        if isinstance(path, str):
+            path = {path: value}
+        batch_size = batch_size or self.batch_size
+        return await _run_coros_in_chunks(
+            [self._pipe_file(k, v, **kwargs) for k, v in path.items()],
+            batch_size=batch_size,
+            nofiles=True,
+        )
+
+    async def _process_limits(self, url, start, end):
+        """Helper for "Range"-based _cat_file"""
+        size = None
+        suff = False
+        if start is not None and start < 0:
+            # if start is negative and end None, end is the "suffix length"
+            if end is None:
+                end = -start
+                start = ""
+                suff = True
+            else:
+                size = size or (await self._info(url))["size"]
+                start = size + start
+        elif start is None:
+            start = 0
+        if not suff:
+            if end is not None and end < 0:
+                if start is not None:
+                    size = size or (await self._info(url))["size"]
+                    end = size + end
+            elif end is None:
+                end = ""
+            if isinstance(end, numbers.Integral):
+                end -= 1  # bytes range is inclusive
+        return f"bytes={start}-{end}"
+
+    async def _cat_file(self, path, start=None, end=None, **kwargs):
+        raise NotImplementedError
+
+    async def _cat(
+        self, path, recursive=False, on_error="raise", batch_size=None, **kwargs
+    ):
+        paths = await self._expand_path(path, recursive=recursive)
+        coros = [self._cat_file(path, **kwargs) for path in paths]
+        batch_size = batch_size or self.batch_size
+        out = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+        )
+        if on_error == "raise":
+            ex = next(filter(is_exception, out), False)
+            if ex:
+                raise ex
+        if (
+            len(paths) > 1
+            or isinstance(path, list)
+            or paths[0] != self._strip_protocol(path)
+        ):
+            return {
+                k: v
+                for k, v in zip(paths, out)
+                if on_error != "omit" or not is_exception(v)
+            }
+        else:
+            return out[0]
+
+    async def _cat_ranges(
+        self,
+        paths,
+        starts,
+        ends,
+        max_gap=None,
+        batch_size=None,
+        on_error="return",
+        **kwargs,
+    ):
+        """Get the contents of byte ranges from one or more files
+
+        Parameters
+        ----------
+        paths: list
+            A list of of filepaths on this filesystems
+        starts, ends: int or list
+            Bytes limits of the read. If using a single int, the same value will be
+            used to read all the specified files.
+        on_error: "return" or "raise"
+            If "return" (default), any per-range exception is placed in the output
+            list at the corresponding position. Otherwise the first such exception
+            is raised. Matches ``AbstractFileSystem.cat_ranges``.
+        """
+        if max_gap is not None:
+            # use utils.merge_offset_ranges
+            raise NotImplementedError
+        if not isinstance(paths, list):
+            raise TypeError
+        if not isinstance(starts, Iterable):
+            starts = [starts] * len(paths)
+        if not isinstance(ends, Iterable):
+            ends = [ends] * len(paths)
+        if len(starts) != len(paths) or len(ends) != len(paths):
+            raise ValueError
+        coros = [
+            self._cat_file(p, start=s, end=e, **kwargs)
+            for p, s, e in zip(paths, starts, ends)
+        ]
+        batch_size = batch_size or self.batch_size
+        out = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, nofiles=True, return_exceptions=True
+        )
+        if on_error != "return":
+            ex = next(filter(is_exception, out), None)
+            if ex is not None:
+                raise ex
+        return out
+
+    async def _put_file(self, lpath, rpath, mode="overwrite", **kwargs):
+        raise NotImplementedError
+
+    async def _put(
+        self,
+        lpath,
+        rpath,
+        recursive=False,
+        callback=DEFAULT_CALLBACK,
+        batch_size=None,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) from local.
+
+        Copies a specific file or tree of files (if recursive=True). If rpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within.
+
+        The put_file method will be called concurrently on a batch of files. The
+        batch_size option can configure the amount of futures that can be executed
+        at the same time. If it is -1, then all the files will be uploaded concurrently.
+        The default can be set for this instance by passing "batch_size" in the
+        constructor, or for all instances by setting the "gather_batch_size" key
+        in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            source_is_str = isinstance(lpath, str)
+            if source_is_str:
+                lpath = make_path_posix(lpath)
+            fs = LocalFileSystem()
+            lpaths = fs.expand_path(lpath, recursive=recursive, maxdepth=maxdepth)
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+                if not lpaths:
+                    return
+
+            source_is_file = len(lpaths) == 1
+            dest_is_dir = isinstance(rpath, str) and (
+                trailing_sep(rpath) or await self._isdir(rpath)
+            )
+
+            rpath = self._strip_protocol(rpath)
+            exists = source_is_str and (
+                (has_magic(lpath) and source_is_file)
+                or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+            )
+            rpaths = other_paths(
+                lpaths,
+                rpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        is_dir = {l: os.path.isdir(l) for l in lpaths}
+        rdirs = [r for l, r in zip(lpaths, rpaths) if is_dir[l]]
+        file_pairs = [(l, r) for l, r in zip(lpaths, rpaths) if not is_dir[l]]
+
+        await asyncio.gather(*[self._makedirs(d, exist_ok=True) for d in rdirs])
+        batch_size = batch_size or self.batch_size
+
+        coros = []
+        callback.set_size(len(file_pairs))
+        for lfile, rfile in file_pairs:
+            put_file = callback.branch_coro(self._put_file)
+            coros.append(put_file(lfile, rfile, **kwargs))
+
+        return await _run_coros_in_chunks(
+            coros, batch_size=batch_size, callback=callback
+        )
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        raise NotImplementedError
+
+    async def _get(
+        self,
+        rpath,
+        lpath,
+        recursive=False,
+        callback=DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) to local.
+
+        Copies a specific file or tree of files (if recursive=True). If lpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within. Can submit a list of paths, which may be glob-patterns
+        and will be expanded.
+
+        The get_file method will be called concurrently on a batch of files. The
+        batch_size option can configure the amount of futures that can be executed
+        at the same time. If it is -1, then all the files will be uploaded concurrently.
+        The default can be set for this instance by passing "batch_size" in the
+        constructor, or for all instances by setting the "gather_batch_size" key
+        in ``fsspec.config.conf``, falling back to 1/8th of the system limit .
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            source_is_str = isinstance(rpath, str)
+            # First check for rpath trailing slash as _strip_protocol removes it.
+            source_not_trailing_sep = source_is_str and not trailing_sep(rpath)
+            rpath = self._strip_protocol(rpath)
+            rpaths = await self._expand_path(
+                rpath, recursive=recursive, maxdepth=maxdepth
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                rpaths = [
+                    p for p in rpaths if not (trailing_sep(p) or await self._isdir(p))
+                ]
+                if not rpaths:
+                    return
+
+            lpath = make_path_posix(lpath)
+            source_is_file = len(rpaths) == 1
+            dest_is_dir = isinstance(lpath, str) and (
+                trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+            )
+
+            exists = source_is_str and (
+                (has_magic(rpath) and source_is_file)
+                or (not has_magic(rpath) and dest_is_dir and source_not_trailing_sep)
+            )
+            lpaths = other_paths(
+                rpaths,
+                lpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+            if isinstance(lpath, str):
+                # The names came from the source listing; ".." in one of them
+                # would otherwise place the copy above the destination. When
+                # lpath is a list the caller named every destination itself.
+                check_contained(lpath, lpaths)
+
+        [os.makedirs(os.path.dirname(lp), exist_ok=True) for lp in lpaths]
+        batch_size = kwargs.pop("batch_size", self.batch_size)
+
+        coros = []
+        callback.set_size(len(lpaths))
+        for lpath, rpath in zip(lpaths, rpaths):
+            get_file = callback.branch_coro(self._get_file)
+            coros.append(get_file(rpath, lpath, **kwargs))
+        return await _run_coros_in_chunks(
+            coros, batch_size=batch_size, callback=callback
+        )
+
+    async def _isfile(self, path):
+        try:
+            return (await self._info(path))["type"] == "file"
+        except Exception:
+            return False
+
+    async def _isdir(self, path):
+        try:
+            return (await self._info(path))["type"] == "directory"
+        except OSError:
+            return False
+
+    async def _size(self, path):
+        return (await self._info(path)).get("size", None)
+
+    async def _sizes(self, paths, batch_size=None):
+        batch_size = batch_size or self.batch_size
+        return await _run_coros_in_chunks(
+            [self._size(p) for p in paths], batch_size=batch_size
+        )
+
+    async def _exists(self, path, **kwargs):
+        try:
+            await self._info(path, **kwargs)
+            return True
+        except FileNotFoundError:
+            return False
+
+    async def _info(self, path, **kwargs):
+        raise NotImplementedError
+
+    async def _ls(self, path, detail=True, **kwargs):
+        raise NotImplementedError
+
+    async def _walk(self, path, maxdepth=None, topdown=True, on_error="omit", **kwargs):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        path = self._strip_protocol(path)
+        full_dirs = {}
+        dirs = {}
+        files = {}
+
+        detail = kwargs.pop("detail", False)
+        try:
+            listing = await self._ls(path, detail=True, **kwargs)
+        except (FileNotFoundError, OSError) as e:
+            if on_error == "raise":
+                raise
+            elif callable(on_error):
+                on_error(e)
+            if detail:
+                yield path, {}, {}
+            else:
+                yield path, [], []
+            return
+
+        for info in listing:
+            # each info name must be at least [path]/part , but here
+            # we check also for names like [path]/part/
+            pathname = info["name"].rstrip("/")
+            name = pathname.rsplit("/", 1)[-1]
+            if info["type"] == "directory" and pathname != path:
+                # do not include "self" path
+                full_dirs[name] = pathname
+                dirs[name] = info
+            elif pathname == path:
+                # file-like with same name as give path
+                files[""] = info
+            else:
+                files[name] = info
+
+        if not detail:
+            dirs = list(dirs)
+            files = list(files)
+
+        if topdown:
+            # Yield before recursion if walking top down
+            yield path, dirs, files
+
+        if maxdepth is not None:
+            maxdepth -= 1
+            if maxdepth < 1:
+                if not topdown:
+                    yield path, dirs, files
+                return
+
+        for d in dirs:
+            async for _ in self._walk(
+                full_dirs[d],
+                maxdepth=maxdepth,
+                detail=detail,
+                topdown=topdown,
+                **kwargs,
+            ):
+                yield _
+
+        if not topdown:
+            # Yield after recursion if walking bottom up
+            yield path, dirs, files
+
+    async def _glob(self, path, maxdepth=None, **kwargs):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        import re
+
+        seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+        ends_with_sep = path.endswith(seps)  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_sep or path.endswith(
+            tuple(sep + "**" for sep in seps)
+        )
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_qmark, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+        withdirs = kwargs.pop("withdirs", True)
+
+        if not has_magic(path):
+            if await self._exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: await self._info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            first_wildcard_idx = min_idx
+            min_idx = path[:min_idx].rindex("/")
+            root = path[
+                : min_idx + 1
+            ]  # everything up to the last / before the first wildcard
+            prefix = path[
+                min_idx + 1 : first_wildcard_idx
+            ]  # stem between last "/" and first wildcard
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            prefix = path[:min_idx]  # stem up to the first wildcard
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        # Pass the filename stem as prefix= so backends that support it such as
+        # gcsfs, s3fs and adlfs can filter server-side up to the first wildcard.
+        if prefix:
+            kwargs["prefix"] = prefix
+        allpaths = await self._find(
+            root, maxdepth=depth, withdirs=withdirs, detail=True, **kwargs
+        )
+
+        pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                p + "/"
+                if append_slash_to_dirname and info["type"] == "directory"
+                else p
+            )
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    async def _du(self, path, total=True, maxdepth=None, **kwargs):
+        sizes = {}
+        # async for?
+        for f in await self._find(path, maxdepth=maxdepth, **kwargs):
+            info = await self._info(f)
+            sizes[info["name"]] = info["size"]
+        if total:
+            return sum(sizes.values())
+        else:
+            return sizes
+
+    async def _find(self, path, maxdepth=None, withdirs=False, **kwargs):
+        path = self._strip_protocol(path)
+        out = {}
+        detail = kwargs.pop("detail", False)
+
+        # Add the root directory if withdirs is requested
+        # This is needed for posix glob compliance
+        if withdirs and path != "" and await self._isdir(path):
+            out[path] = await self._info(path)
+
+        # async for?
+        async for _, dirs, files in self._walk(path, maxdepth, detail=True, **kwargs):
+            if withdirs:
+                files.update(dirs)
+            out.update({info["name"]: info for name, info in files.items()})
+        if not out and (await self._isfile(path)):
+            # walk works on directories, but find should also return [path]
+            # when path happens to be a file
+            out[path] = {}
+        names = sorted(out)
+        if not detail:
+            return names
+        else:
+            return {name: out[name] for name in names}
+
+    async def _expand_path(
+        self, path, recursive=False, maxdepth=None, assume_literal=False
+    ):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        if isinstance(path, str):
+            out = await self._expand_path([path], recursive, maxdepth)
+        else:
+            out = set()
+            path = [self._strip_protocol(p) for p in path]
+            for p in path:  # can gather here
+                if not assume_literal and has_magic(p):
+                    bit = set(await self._glob(p, maxdepth=maxdepth))
+                    out |= bit
+                    if recursive:
+                        # glob call above expanded one depth so if maxdepth is defined
+                        # then decrement it in expand_path call below. If it is zero
+                        # after decrementing then avoid expand_path call.
+                        if maxdepth is not None and maxdepth <= 1:
+                            continue
+                        out |= set(
+                            await self._expand_path(
+                                list(bit),
+                                recursive=recursive,
+                                maxdepth=maxdepth - 1 if maxdepth is not None else None,
+                                assume_literal=True,
+                            )
+                        )
+                    continue
+                elif recursive:
+                    rec = set(await self._find(p, maxdepth=maxdepth, withdirs=True))
+                    out |= rec
+                if p not in out and (recursive is False or (await self._exists(p))):
+                    # should only check once, for the root
+                    out.add(p)
+        if not out:
+            raise FileNotFoundError(path)
+        return sorted(out)
+
+    async def _mkdir(self, path, create_parents=True, **kwargs):
+        pass  # not necessary to implement, may not have directories
+
+    async def _makedirs(self, path, exist_ok=False):
+        pass  # not necessary to implement, may not have directories
+
+    async def open_async(self, path, mode="rb", **kwargs):
+        if "b" not in mode or kwargs.get("compression"):
+            raise ValueError
+        raise NotImplementedError
+
+
+def mirror_sync_methods(obj):
+    """Populate sync and async methods for obj
+
+    For each method will create a sync version if the name refers to an async method
+    (coroutine) and there is no override in the child class; will create an async
+    method for the corresponding sync method if there is no implementation.
+
+    Uses the methods specified in
+    - async_methods: the set that an implementation is expected to provide
+    - default_async_methods: that can be derived from their sync version in
+      AbstractFileSystem
+    - AsyncFileSystem: async-specific default coroutines
+    """
+    from fsspec import AbstractFileSystem
+
+    for method in set(async_methods + dir(AsyncFileSystem)):
+        if not method.startswith("_"):
+            continue
+        smethod = method[1:]
+        if private.match(method):
+            isco = inspect.iscoroutinefunction(getattr(obj, method, None))
+            unsync = getattr(getattr(obj, smethod, False), "__func__", None)
+            is_default = unsync is getattr(AbstractFileSystem, smethod, "")
+            if isco and is_default:
+                mth = sync_wrapper(getattr(obj, method), obj=obj)
+            elif inspect.isasyncgenfunction(getattr(obj, method, None)) and is_default:
+                mth = async_gen_wrapper(getattr(obj, method), obj=obj)
+            else:
+                continue
+            setattr(obj, smethod, mth)
+            if not mth.__doc__:
+                mth.__doc__ = getattr(
+                    getattr(AbstractFileSystem, smethod, None), "__doc__", ""
+                )
+
+
+class FSSpecCoroutineCancel(Exception):
+    pass
+
+
+def _dump_running_tasks(
+    printout=True, cancel=True, exc=FSSpecCoroutineCancel, with_task=False
+):
+    import traceback
+
+    tasks = [t for t in asyncio.tasks.all_tasks(loop[0]) if not t.done()]
+    if printout:
+        [task.print_stack() for task in tasks]
+    out = [
+        {
+            "locals": task._coro.cr_frame.f_locals,
+            "file": task._coro.cr_frame.f_code.co_filename,
+            "firstline": task._coro.cr_frame.f_code.co_firstlineno,
+            "linelo": task._coro.cr_frame.f_lineno,
+            "stack": traceback.format_stack(task._coro.cr_frame),
+            "task": task if with_task else None,
+        }
+        for task in tasks
+    ]
+    if cancel:
+        for t in tasks:
+            cbs = t._callbacks
+            t.cancel()
+            asyncio.futures.Future.set_exception(t, exc)
+            asyncio.futures.Future.cancel(t)
+            [cb[0](t) for cb in cbs]  # cancels any dependent concurrent.futures
+            try:
+                t._coro.throw(exc)  # exits coro, unless explicitly handled
+            except exc:
+                pass
+    return out
+
+
+class AbstractAsyncStreamedFile(AbstractBufferedFile):
+    # no read buffering, and always auto-commit
+    # TODO: readahead might still be useful here, but needs async version
+
+    async def read(self, length=-1):
+        """
+        Return data from cache, or fetch pieces as necessary
+
+        Parameters
+        ----------
+        length: int (-1)
+            Number of bytes to read; if <0, all remaining bytes.
+        """
+        length = -1 if length is None else int(length)
+        if self.mode != "rb":
+            raise ValueError("File not in read mode")
+        if length < 0:
+            length = self.size - self.loc
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if length == 0:
+            # don't even bother calling fetch
+            return b""
+        out = await self._fetch_range(self.loc, self.loc + length)
+        self.loc += len(out)
+        return out
+
+    async def write(self, data):
+        """
+        Write data to buffer.
+
+        Buffer only sent on flush() or if buffer is greater than
+        or equal to blocksize.
+
+        Parameters
+        ----------
+        data: bytes
+            Set of bytes to be written.
+        """
+        if self.mode not in {"wb", "ab"}:
+            raise ValueError("File not in write mode")
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if self.forced:
+            raise ValueError("This file has been force-flushed, can only close")
+        out = self.buffer.write(data)
+        self.loc += out
+        if self.buffer.tell() >= self.blocksize:
+            await self.flush()
+        return out
+
+    async def close(self):
+        """Close file
+
+        Finalizes writes, discards cache
+        """
+        if getattr(self, "_unclosable", False):
+            return
+        if self.closed:
+            return
+        if self.mode == "rb":
+            self.cache = None
+        else:
+            if not self.forced:
+                await self.flush(force=True)
+
+            if self.fs is not None:
+                self.fs.invalidate_cache(self.path)
+                self.fs.invalidate_cache(self.fs._parent(self.path))
+
+        self.closed = True
+
+    async def flush(self, force=False):
+        if self.closed:
+            raise ValueError("Flush on closed file")
+        if force and self.forced:
+            raise ValueError("Force flush cannot be called more than once")
+        if force:
+            self.forced = True
+
+        if self.mode not in {"wb", "ab"}:
+            # no-op to flush on read-mode
+            return
+
+        if not force and self.buffer.tell() < self.blocksize:
+            # Defer write on small block
+            return
+
+        if self.offset is None:
+            # Initialize a multipart upload
+            self.offset = 0
+            try:
+                await self._initiate_upload()
+            except:
+                self.closed = True
+                raise
+
+        if await self._upload_chunk(final=force) is not False:
+            self.offset += self.buffer.seek(0, 2)
+            self.buffer = io.BytesIO()
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def _fetch_range(self, start, end):
+        raise NotImplementedError
+
+    async def _initiate_upload(self):
+        pass
+
+    async def _upload_chunk(self, final=False):
+        raise NotImplementedError
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/caching.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/caching.py
new file mode 100644
index 0000000000000000000000000000000000000000..5cf220067913029ea17149a76a7d14bbe07695eb
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/caching.py
@@ -0,0 +1,1142 @@
+from __future__ import annotations
+
+import asyncio
+import collections
+import functools
+import logging
+import math
+import os
+import threading
+from collections import OrderedDict
+from collections.abc import Callable
+from concurrent.futures import Future, ThreadPoolExecutor
+from itertools import groupby
+from operator import itemgetter
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, NamedTuple, TypeVar
+
+if TYPE_CHECKING:
+    import mmap
+
+    from typing_extensions import ParamSpec
+
+    P = ParamSpec("P")
+else:
+    P = TypeVar("P")
+
+T = TypeVar("T")
+
+
+logger = logging.getLogger("fsspec.caching")
+
+Fetcher = Callable[[int, int], bytes]  # Maps (start, end) to bytes
+MultiFetcher = Callable[[list[int, int]], bytes]  # Maps [(start, end)] to bytes
+
+
+class BaseCache:
+    """Pass-though cache: doesn't keep anything, calls every time
+
+    Acts as base class for other cachers
+
+    Parameters
+    ----------
+    blocksize: int
+        How far to read ahead in numbers of bytes
+    fetcher: func
+        Function of the form f(start, end) which gets bytes from remote as
+        specified
+    size: int
+        How big this file is
+    """
+
+    name: ClassVar[str] = "none"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        self.blocksize = blocksize
+        self.nblocks = 0
+        self.fetcher = fetcher
+        self.size = size
+        self.hit_count = 0
+        self.miss_count = 0
+        # the bytes that we actually requested
+        self.total_requested_bytes = 0
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if stop is None:
+            stop = self.size
+        if start >= self.size or start >= stop:
+            return b""
+        return self.fetcher(start, stop)
+
+    def _reset_stats(self) -> None:
+        """Reset hit and miss counts for a more ganular report e.g. by file."""
+        self.hit_count = 0
+        self.miss_count = 0
+        self.total_requested_bytes = 0
+
+    def _log_stats(self) -> str:
+        """Return a formatted string of the cache statistics."""
+        if self.hit_count == 0 and self.miss_count == 0:
+            # a cache that does nothing, this is for logs only
+            return ""
+        return f" , {self.name}: {self.hit_count} hits, {self.miss_count} misses, {self.total_requested_bytes} total requested bytes"
+
+    def __repr__(self) -> str:
+        # TODO: use rich for better formatting
+        return f"""
+        <{self.__class__.__name__}:
+            block size  :   {self.blocksize}
+            block count :   {self.nblocks}
+            file size   :   {self.size}
+            cache hits  :   {self.hit_count}
+            cache misses:   {self.miss_count}
+            total requested bytes: {self.total_requested_bytes}>
+        """
+
+
+class MMapCache(BaseCache):
+    """memory-mapped sparse file cache
+
+    Opens temporary file, which is filled blocks-wise when data is requested.
+    Ensure there is enough disc space in the temporary location.
+
+    This cache method might only work on posix
+
+    Parameters
+    ----------
+    blocksize: int
+        How far to read ahead in numbers of bytes
+    fetcher: Fetcher
+        Function of the form f(start, end) which gets bytes from remote as
+        specified
+    size: int
+        How big this file is
+    location: str
+        Where to create the temporary file. If None, a temporary file is
+        created using tempfile.TemporaryFile().
+    blocks: set[int]
+        Set of block numbers that have already been fetched. If None, an empty
+        set is created.
+    multi_fetcher: MultiFetcher
+        Function of the form f([(start, end)]) which gets bytes from remote
+        as specified. This function is used to fetch multiple blocks at once.
+        If not specified, the fetcher function is used instead.
+    """
+
+    name = "mmap"
+
+    def __init__(
+        self,
+        blocksize: int,
+        fetcher: Fetcher,
+        size: int,
+        location: str | None = None,
+        blocks: set[int] | None = None,
+        multi_fetcher: MultiFetcher | None = None,
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.blocks = set() if blocks is None else blocks
+        self.location = location
+        self.multi_fetcher = multi_fetcher
+        self.cache = self._makefile()
+
+    def _makefile(self) -> mmap.mmap | bytearray:
+        import mmap
+        import tempfile
+
+        if self.size == 0:
+            return bytearray()
+
+        # posix version
+        if self.location is None or not os.path.exists(self.location):
+            if self.location is None:
+                fd = tempfile.TemporaryFile()
+                self.blocks = set()
+            else:
+                fd = open(self.location, "wb+")
+            fd.seek(self.size - 1)
+            fd.write(b"1")
+            fd.flush()
+        else:
+            fd = open(self.location, "r+b")
+
+        return mmap.mmap(fd.fileno(), self.size)
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        logger.debug(f"MMap cache fetching {start}-{end}")
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        start_block = start // self.blocksize
+        end_block = end // self.blocksize
+        block_range = range(start_block, end_block + 1)
+        # Determine which blocks need to be fetched. This sequence is sorted by construction.
+        need = (i for i in block_range if i not in self.blocks)
+        # Count the number of blocks already cached
+        self.hit_count += sum(1 for i in block_range if i in self.blocks)
+
+        ranges = []
+
+        # Consolidate needed blocks.
+        # Algorithm adapted from Python 2.x itertools documentation.
+        # We are grouping an enumerated sequence of blocks. By comparing when the difference
+        # between an ascending range (provided by enumerate) and the needed block numbers
+        # we can detect when the block number skips values. The key computes this difference.
+        # Whenever the difference changes, we know that we have previously cached block(s),
+        # and a new group is started. In other words, this algorithm neatly groups
+        # runs of consecutive block numbers so they can be fetched together.
+        for _, _blocks in groupby(enumerate(need), key=lambda x: x[0] - x[1]):
+            # Extract the blocks from the enumerated sequence
+            _blocks = tuple(map(itemgetter(1), _blocks))
+            # Compute start of first block
+            sstart = _blocks[0] * self.blocksize
+            # Compute the end of the last block. Last block may not be full size.
+            send = min(_blocks[-1] * self.blocksize + self.blocksize, self.size)
+
+            # Fetch bytes (could be multiple consecutive blocks)
+            self.total_requested_bytes += send - sstart
+            logger.debug(
+                f"MMap get blocks {_blocks[0]}-{_blocks[-1]} ({sstart}-{send})"
+            )
+            ranges.append((sstart, send))
+
+            # Update set of cached blocks
+            self.blocks.update(_blocks)
+            # Update cache statistics with number of blocks we had to cache
+            self.miss_count += len(_blocks)
+
+        if not ranges:
+            return self.cache[start:end]
+
+        if self.multi_fetcher:
+            logger.debug(f"MMap get blocks {ranges}")
+            for idx, r in enumerate(self.multi_fetcher(ranges)):
+                sstart, send = ranges[idx]
+                logger.debug(f"MMap copy block ({sstart}-{send}")
+                self.cache[sstart:send] = r
+        else:
+            for sstart, send in ranges:
+                logger.debug(f"MMap get block ({sstart}-{send}")
+                self.cache[sstart:send] = self.fetcher(sstart, send)
+
+        return self.cache[start:end]
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        # Remove the unpicklable entries.
+        del state["cache"]
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        # Restore instance attributes
+        self.__dict__.update(state)
+        self.cache = self._makefile()
+
+
+class ReadAheadCache(BaseCache):
+    """Cache which reads only when we get beyond a block of data
+
+    This is a much simpler version of BytesCache, and does not attempt to
+    fill holes in the cache or keep fragments alive. It is best suited to
+    many small reads in a sequential order (e.g., reading lines from a file).
+    """
+
+    name = "readahead"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.cache = b""
+        self.start = 0
+        self.end = 0
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None or end > self.size:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        l = end - start
+        if start >= self.start and end <= self.end:
+            # cache hit
+            self.hit_count += 1
+            return self.cache[start - self.start : end - self.start]
+        elif self.start <= start < self.end:
+            # partial hit
+            self.miss_count += 1
+            part = self.cache[start - self.start :]
+            l -= len(part)
+            start = self.end
+        else:
+            # miss
+            self.miss_count += 1
+            part = b""
+        end = min(self.size, end + self.blocksize)
+        self.total_requested_bytes += end - start
+        self.cache = self.fetcher(start, end)  # new block replaces old
+        self.start = start
+        self.end = self.start + len(self.cache)
+        return part + self.cache[:l]
+
+
+class AdaptiveReadaheadCache(BaseCache):
+    """Cache with adaptive asynchronous prefetching.
+
+    Optimized for sequential and near-sequential reads by dynamically
+    adjusting the amount of data prefetched in the background. The cache
+    uses the generic prefetch engine when async loop support is available,
+    and falls back to ``ReadAheadCache`` when it is not.
+
+    Parameters
+    ----------
+    blocksize: int
+        Nominal read size used by callers.
+    fetcher: Fetcher
+        Function of the form ``f(start, end)`` that returns bytes.
+    size: int
+        Total size of the file.
+    concurrency: int
+        Maximum number of concurrent background fetch tasks.
+    max_prefetch_size: int | None
+        Optional upper bound for adaptive prefetch size in bytes.
+    """
+
+    name = "adaptive"
+
+    def __init__(
+        self,
+        blocksize: int,
+        fetcher: Fetcher,
+        size: int,
+        concurrency: int = 4,
+        max_prefetch_size: int | None = None,
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self._fallback = ReadAheadCache(blocksize, fetcher, size)
+        self._prefetcher = None
+
+        async def _default_fetcher_async(
+            start_offset: int,
+            total_size: int,
+            split_factor: int = 1,
+        ) -> bytes:
+            del split_factor
+            return await asyncio.to_thread(
+                self.fetcher, start_offset, start_offset + total_size
+            )
+
+        try:
+            from . import asyn as fsspec_asyn
+        except ImportError as e:
+            raise ImportError(
+                "AdaptiveReadaheadCache requires fsspec.asyn to be available"
+            ) from e
+
+        try:
+            from .prefetcher import BackgroundPrefetcher
+
+            self._prefetcher = BackgroundPrefetcher(
+                fetcher=_default_fetcher_async,
+                size=size,
+                concurrency=concurrency,
+                max_prefetch_size=max_prefetch_size,
+                loop=fsspec_asyn.get_loop(),
+            )
+            logger.info(
+                "AdaptiveReadaheadCache enabled (blocksize=%d, size=%d, concurrency=%d, max_prefetch_size=%s)",
+                blocksize,
+                size,
+                concurrency,
+                max_prefetch_size,
+            )
+        except Exception as e:
+            logger.info(
+                "AdaptiveReadaheadCache fallback to ReadAheadCache: %s",
+                e,
+                exc_info=True,
+            )
+            self._prefetcher = None
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if self._prefetcher is None:
+            out = self._fallback._fetch(start, end)
+            self.hit_count = self._fallback.hit_count
+            self.miss_count = self._fallback.miss_count
+            self.total_requested_bytes = self._fallback.total_requested_bytes
+            return out
+
+        out = self._prefetcher.fetch(start, end)
+        self.miss_count += 1
+        self.total_requested_bytes += len(out)
+        return out
+
+    def close(self) -> None:
+        if self._prefetcher is not None:
+            self._prefetcher.close()
+            self._prefetcher = None
+
+    def __getstate__(self) -> dict[str, Any]:
+        # The prefetcher owns asyncio primitives that are not picklable.
+        self.close()
+        state = self.__dict__.copy()
+        state["_prefetcher"] = None
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self._prefetcher = None
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            # Best-effort cleanup during GC.
+            pass
+
+
+class FirstChunkCache(BaseCache):
+    """Caches the first block of a file only
+
+    This may be useful for file types where the metadata is stored in the header,
+    but is randomly accessed.
+    """
+
+    name = "first"
+
+    def __init__(self, blocksize: int, fetcher: Fetcher, size: int) -> None:
+        if blocksize > size:
+            # this will buffer the whole thing
+            blocksize = size
+        super().__init__(blocksize, fetcher, size)
+        self.cache: bytes | None = None
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        start = start or 0
+        if start > self.size:
+            logger.debug("FirstChunkCache: requested start > file size")
+            return b""
+
+        if end is None:
+            end = self.size
+        end = min(end, self.size)
+
+        if start < self.blocksize:
+            if self.cache is None:
+                self.miss_count += 1
+                if end > self.blocksize:
+                    self.total_requested_bytes += end
+                    data = self.fetcher(0, end)
+                    self.cache = data[: self.blocksize]
+                    return data[start:]
+                self.cache = self.fetcher(0, self.blocksize)
+                self.total_requested_bytes += self.blocksize
+            part = self.cache[start:end]
+            if end > self.blocksize:
+                self.total_requested_bytes += end - self.blocksize
+                part += self.fetcher(self.blocksize, end)
+            self.hit_count += 1
+            return part
+        else:
+            self.miss_count += 1
+            self.total_requested_bytes += end - start
+            return self.fetcher(start, end)
+
+
+class BlockCache(BaseCache):
+    """
+    Cache holding memory as a set of blocks.
+
+    Requests are only ever made ``blocksize`` at a time, and are
+    stored in an LRU cache. The least recently accessed block is
+    discarded when more than ``maxblocks`` are stored.
+
+    Parameters
+    ----------
+    blocksize : int
+        The number of bytes to store in each block.
+        Requests are only ever made for ``blocksize``, so this
+        should balance the overhead of making a request against
+        the granularity of the blocks.
+    fetcher : Callable
+    size : int
+        The total size of the file being cached.
+    maxblocks : int
+        The maximum number of blocks to cache for. The maximum memory
+        use for this cache is then ``blocksize * maxblocks``.
+    """
+
+    name = "blockcache"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.nblocks = math.ceil(size / blocksize)
+        self.maxblocks = maxblocks
+        self._fetch_block_cached = functools.lru_cache(maxblocks)(self._fetch_block)
+
+    def cache_info(self):
+        """
+        The statistics on the block cache.
+
+        Returns
+        -------
+        NamedTuple
+            Returned directly from the LRU Cache used internally.
+        """
+        return self._fetch_block_cached.cache_info()
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        del state["_fetch_block_cached"]
+        return state
+
+    def __setstate__(self, state: dict[str, Any]) -> None:
+        self.__dict__.update(state)
+        self._fetch_block_cached = functools.lru_cache(state["maxblocks"])(
+            self._fetch_block
+        )
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None or end > self.size:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+
+        return self._read_cache(
+            start, end, start // self.blocksize, (end - 1) // self.blocksize
+        )
+
+    def _fetch_block(self, block_number: int) -> bytes:
+        """
+        Fetch the block of data for `block_number`.
+        """
+        if block_number > self.nblocks:
+            raise ValueError(
+                f"'block_number={block_number}' is greater than "
+                f"the number of blocks ({self.nblocks})"
+            )
+
+        start = block_number * self.blocksize
+        end = start + self.blocksize
+        self.total_requested_bytes += end - start
+        self.miss_count += 1
+        logger.info("BlockCache fetching block %d", block_number)
+        block_contents = super()._fetch(start, end)
+        return block_contents
+
+    def _read_cache(
+        self, start: int, end: int, start_block_number: int, end_block_number: int
+    ) -> bytes:
+        """
+        Read from our block cache.
+
+        Parameters
+        ----------
+        start, end : int
+            The start and end byte positions.
+        start_block_number, end_block_number : int
+            The start and end block numbers.
+        """
+        start_pos = start % self.blocksize
+        end_pos = end % self.blocksize
+        if end_pos == 0:
+            end_pos = self.blocksize
+
+        self.hit_count += 1
+        if start_block_number == end_block_number:
+            block: bytes = self._fetch_block_cached(start_block_number)
+            return block[start_pos:end_pos]
+
+        else:
+            # read from the initial
+            out = [self._fetch_block_cached(start_block_number)[start_pos:]]
+
+            # intermediate blocks
+            # Note: it'd be nice to combine these into one big request. However
+            # that doesn't play nicely with our LRU cache.
+            out.extend(
+                map(
+                    self._fetch_block_cached,
+                    range(start_block_number + 1, end_block_number),
+                )
+            )
+
+            # final block
+            out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+            return b"".join(out)
+
+
+class BytesCache(BaseCache):
+    """Cache which holds data in a in-memory bytes object
+
+    Implements read-ahead by the block size, for semi-random reads progressing
+    through the file.
+
+    Parameters
+    ----------
+    trim: bool
+        As we read more data, whether to discard the start of the buffer when
+        we are more than a blocksize ahead of it.
+    """
+
+    name: ClassVar[str] = "bytes"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, trim: bool = True
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.cache = b""
+        self.start: int | None = None
+        self.end: int | None = None
+        self.trim = trim
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        # TODO: only set start/end after fetch, in case it fails?
+        # is this where retry logic might go?
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+        if (
+            self.start is not None
+            and start >= self.start
+            and self.end is not None
+            and end < self.end
+        ):
+            # cache hit: we have all the required data
+            offset = start - self.start
+            self.hit_count += 1
+            return self.cache[offset : offset + end - start]
+
+        if self.blocksize:
+            bend = min(self.size, end + self.blocksize)
+        else:
+            bend = end
+
+        if bend == start or start > self.size:
+            return b""
+
+        if (self.start is None or start < self.start) and (
+            self.end is None or end > self.end
+        ):
+            # First read, or extending both before and after
+            self.total_requested_bytes += bend - start
+            self.miss_count += 1
+            self.cache = self.fetcher(start, bend)
+            self.start = start
+        else:
+            assert self.start is not None
+            assert self.end is not None
+            self.miss_count += 1
+
+            if start < self.start:
+                if self.end is None or self.end - end > self.blocksize:
+                    self.total_requested_bytes += bend - start
+                    self.cache = self.fetcher(start, bend)
+                    self.start = start
+                else:
+                    self.total_requested_bytes += self.start - start
+                    new = self.fetcher(start, self.start)
+                    self.start = start
+                    self.cache = new + self.cache
+            elif self.end is not None and bend > self.end:
+                if self.end > self.size:
+                    pass
+                elif end - self.end > self.blocksize:
+                    self.total_requested_bytes += bend - start
+                    self.cache = self.fetcher(start, bend)
+                    self.start = start
+                else:
+                    self.total_requested_bytes += bend - self.end
+                    new = self.fetcher(self.end, bend)
+                    self.cache = self.cache + new
+
+        self.end = self.start + len(self.cache)
+        offset = start - self.start
+        out = self.cache[offset : offset + end - start]
+        if self.trim:
+            num = (self.end - self.start) // (self.blocksize + 1)
+            if num > 1:
+                self.start += self.blocksize * num
+                self.cache = self.cache[self.blocksize * num :]
+        return out
+
+    def __len__(self) -> int:
+        return len(self.cache)
+
+
+class AllBytes(BaseCache):
+    """Cache entire contents of the file"""
+
+    name: ClassVar[str] = "all"
+
+    def __init__(
+        self,
+        blocksize: int | None = None,
+        fetcher: Fetcher | None = None,
+        size: int | None = None,
+        data: bytes | None = None,
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)  # type: ignore[arg-type]
+        if data is None:
+            self.miss_count += 1
+            self.total_requested_bytes += self.size
+            data = self.fetcher(0, self.size)
+        self.data = data
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        self.hit_count += 1
+        return self.data[start:stop]
+
+
+class KnownPartsOfAFile(BaseCache):
+    """
+    Cache holding known file parts.
+
+    Parameters
+    ----------
+    blocksize: int
+        How far to read ahead in numbers of bytes
+    fetcher: func
+        Function of the form f(start, end) which gets bytes from remote as
+        specified
+    size: int
+        How big this file is
+    data: dict
+        A dictionary mapping explicit `(start, stop)` file-offset tuples
+        with known bytes.
+    strict: bool, default True
+        Whether to fetch reads that go beyond a known byte-range boundary.
+        If `False`, any read that ends outside a known part will be zero
+        padded. Note that zero padding will not be used for reads that
+        begin outside a known byte-range.
+    """
+
+    name: ClassVar[str] = "parts"
+
+    def __init__(
+        self,
+        blocksize: int,
+        fetcher: Fetcher,
+        size: int,
+        data: dict[tuple[int, int], bytes] | None = None,
+        strict: bool = False,
+        **_: Any,
+    ):
+        super().__init__(blocksize, fetcher, size)
+        self.strict = strict
+
+        # simple consolidation of contiguous blocks
+        if data:
+            old_offsets = sorted(data.keys())
+            offsets = [old_offsets[0]]
+            blocks = [data.pop(old_offsets[0])]
+            for start, stop in old_offsets[1:]:
+                start0, stop0 = offsets[-1]
+                if start == stop0:
+                    offsets[-1] = (start0, stop)
+                    blocks[-1] += data.pop((start, stop))
+                else:
+                    offsets.append((start, stop))
+                    blocks.append(data.pop((start, stop)))
+
+            self.data = dict(zip(offsets, blocks))
+        else:
+            self.data = {}
+
+    @property
+    def size(self):
+        return sum(_[1] - _[0] for _ in self.data)
+
+    @size.setter
+    def size(self, value):
+        pass
+
+    @property
+    def nblocks(self):
+        return len(self.data)
+
+    @nblocks.setter
+    def nblocks(self, value):
+        pass
+
+    def _fetch(self, start: int | None, stop: int | None) -> bytes:
+        logger.debug("Known parts request %s %s", start, stop)
+        if start is None:
+            start = 0
+        if stop is None:
+            stop = self.size
+        self.total_requested_bytes += stop - start
+        out = b""
+        started = False
+        loc_old = 0
+        for loc0, loc1 in sorted(self.data):
+            if (loc0 <= start < loc1) and (loc0 <= stop <= loc1):
+                # entirely within the block
+                off = start - loc0
+                self.hit_count += 1
+                return self.data[(loc0, loc1)][off : off + stop - start]
+            if stop <= loc0:
+                break
+            if started and loc0 > loc_old:
+                # a gap where we need data
+                self.miss_count += 1
+                if self.strict:
+                    raise ValueError
+                out += b"\x00" * (loc0 - loc_old)
+            if loc0 <= start < loc1:
+                # found the start
+                self.hit_count += 1
+                off = start - loc0
+                out = self.data[(loc0, loc1)][off : off + stop - start]
+                started = True
+            elif start < loc0 and stop > loc1:
+                # the whole block
+                self.hit_count += 1
+                out += self.data[(loc0, loc1)]
+            elif loc0 <= stop <= loc1:
+                # end block
+                self.hit_count += 1
+                out = out + self.data[(loc0, loc1)][: stop - loc0]
+                return out
+            loc_old = loc1
+        self.miss_count += 1
+        if started and not self.strict:
+            out = out + b"\x00" * (stop - loc_old)
+            return out
+        raise ValueError
+
+
+class UpdatableLRU(Generic[P, T]):
+    """
+    Custom implementation of LRU cache that allows updating keys
+
+    Used by BackgroundBlockCache
+    """
+
+    class CacheInfo(NamedTuple):
+        hits: int
+        misses: int
+        maxsize: int
+        currsize: int
+
+    def __init__(self, func: Callable[P, T], max_size: int = 128) -> None:
+        self._cache: OrderedDict[Any, T] = collections.OrderedDict()
+        self._func = func
+        self._max_size = max_size
+        self._hits = 0
+        self._misses = 0
+        self._lock = threading.Lock()
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> T:
+        if kwargs:
+            raise TypeError(f"Got unexpected keyword argument {kwargs.keys()}")
+        with self._lock:
+            if args in self._cache:
+                self._cache.move_to_end(args)
+                self._hits += 1
+                return self._cache[args]
+
+        result = self._func(*args, **kwargs)
+
+        with self._lock:
+            self._cache[args] = result
+            self._misses += 1
+            if len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+        return result
+
+    def is_key_cached(self, *args: Any) -> bool:
+        with self._lock:
+            return args in self._cache
+
+    def add_key(self, result: T, *args: Any) -> None:
+        with self._lock:
+            self._cache[args] = result
+            if len(self._cache) > self._max_size:
+                self._cache.popitem(last=False)
+
+    def cache_info(self) -> UpdatableLRU.CacheInfo:
+        with self._lock:
+            return self.CacheInfo(
+                maxsize=self._max_size,
+                currsize=len(self._cache),
+                hits=self._hits,
+                misses=self._misses,
+            )
+
+
+class BackgroundBlockCache(BaseCache):
+    """
+    Cache holding memory as a set of blocks with pre-loading of
+    the next block in the background.
+
+    Requests are only ever made ``blocksize`` at a time, and are
+    stored in an LRU cache. The least recently accessed block is
+    discarded when more than ``maxblocks`` are stored. If the
+    next block is not in cache, it is loaded in a separate thread
+    in non-blocking way.
+
+    Parameters
+    ----------
+    blocksize : int
+        The number of bytes to store in each block.
+        Requests are only ever made for ``blocksize``, so this
+        should balance the overhead of making a request against
+        the granularity of the blocks.
+    fetcher : Callable
+    size : int
+        The total size of the file being cached.
+    maxblocks : int
+        The maximum number of blocks to cache for. The maximum memory
+        use for this cache is then ``blocksize * maxblocks``.
+    """
+
+    name: ClassVar[str] = "background"
+
+    def __init__(
+        self, blocksize: int, fetcher: Fetcher, size: int, maxblocks: int = 32
+    ) -> None:
+        super().__init__(blocksize, fetcher, size)
+        self.nblocks = math.ceil(size / blocksize)
+        self.maxblocks = maxblocks
+        self._fetch_block_cached = UpdatableLRU(self._fetch_block, maxblocks)
+
+        self._thread_executor = ThreadPoolExecutor(max_workers=1)
+        self._fetch_future_block_number: int | None = None
+        self._fetch_future: Future[bytes] | None = None
+        self._fetch_future_lock = threading.Lock()
+        self._closed = False
+
+    def cache_info(self) -> UpdatableLRU.CacheInfo:
+        """
+        The statistics on the block cache.
+
+        Returns
+        -------
+        NamedTuple
+            Returned directly from the LRU Cache used internally.
+        """
+        return self._fetch_block_cached.cache_info()
+
+    def close(self) -> None:
+        """Cancel pending work and shut down the background worker."""
+        with self._fetch_future_lock:
+            if self._closed:
+                return
+            self._closed = True
+            future = self._fetch_future
+            self._fetch_future = None
+            self._fetch_future_block_number = None
+
+        if future is not None:
+            future.cancel()
+        self._thread_executor.shutdown(wait=True, cancel_futures=True)
+
+        # UpdatableLRU stores a bound method and otherwise forms a reference cycle.
+        del self._fetch_block_cached
+
+    def __getstate__(self) -> dict[str, Any]:
+        state = self.__dict__.copy()
+        del state["_fetch_block_cached"]
+        del state["_thread_executor"]
+        del state["_fetch_future_block_number"]
+        del state["_fetch_future"]
+        del state["_fetch_future_lock"]
+        return state
+
+    def __setstate__(self, state) -> None:
+        self.__dict__.update(state)
+        self._fetch_block_cached = UpdatableLRU(self._fetch_block, state["maxblocks"])
+        self._thread_executor = ThreadPoolExecutor(max_workers=1)
+        self._fetch_future_block_number = None
+        self._fetch_future = None
+        self._fetch_future_lock = threading.Lock()
+        self._closed = False
+
+    def _fetch(self, start: int | None, end: int | None) -> bytes:
+        if start is None:
+            start = 0
+        if end is None or end > self.size:
+            end = self.size
+        if start >= self.size or start >= end:
+            return b""
+
+        # byte position -> block numbers
+        start_block_number = start // self.blocksize
+        end_block_number = end // self.blocksize
+
+        fetch_future_block_number = None
+        fetch_future = None
+        with self._fetch_future_lock:
+            # Background thread is running. Check we we can or must join it.
+            if self._fetch_future is not None:
+                assert self._fetch_future_block_number is not None
+                if self._fetch_future.done():
+                    logger.info("BlockCache joined background fetch without waiting.")
+                    self._fetch_block_cached.add_key(
+                        self._fetch_future.result(), self._fetch_future_block_number
+                    )
+                    # Cleanup the fetch variables. Done with fetching the block.
+                    self._fetch_future_block_number = None
+                    self._fetch_future = None
+                else:
+                    # Must join if we need the block for the current fetch
+                    must_join = bool(
+                        start_block_number
+                        <= self._fetch_future_block_number
+                        <= end_block_number
+                    )
+                    if must_join:
+                        # Copy to the local variables to release lock
+                        # before waiting for result
+                        fetch_future_block_number = self._fetch_future_block_number
+                        fetch_future = self._fetch_future
+
+                        # Cleanup the fetch variables. Have a local copy.
+                        self._fetch_future_block_number = None
+                        self._fetch_future = None
+
+        # Need to wait for the future for the current read
+        if fetch_future is not None:
+            logger.info("BlockCache waiting for background fetch.")
+            # Wait until result and put it in cache
+            self._fetch_block_cached.add_key(
+                fetch_future.result(), fetch_future_block_number
+            )
+
+        # these are cached, so safe to do multiple calls for the same start and end.
+        for block_number in range(start_block_number, end_block_number + 1):
+            self._fetch_block_cached(block_number)
+
+        # fetch next block in the background if nothing is running in the background,
+        # the block is within file and it is not already cached
+        end_block_plus_1 = end_block_number + 1
+        with self._fetch_future_lock:
+            if (
+                self._fetch_future is None
+                and end_block_plus_1 <= self.nblocks
+                and not self._fetch_block_cached.is_key_cached(end_block_plus_1)
+            ):
+                self._fetch_future_block_number = end_block_plus_1
+                self._fetch_future = self._thread_executor.submit(
+                    self._fetch_block, end_block_plus_1, "async"
+                )
+
+        return self._read_cache(
+            start,
+            end,
+            start_block_number=start_block_number,
+            end_block_number=end_block_number,
+        )
+
+    def _fetch_block(self, block_number: int, log_info: str = "sync") -> bytes:
+        """
+        Fetch the block of data for `block_number`.
+        """
+        if block_number > self.nblocks:
+            raise ValueError(
+                f"'block_number={block_number}' is greater than "
+                f"the number of blocks ({self.nblocks})"
+            )
+
+        start = block_number * self.blocksize
+        end = start + self.blocksize
+        logger.info("BlockCache fetching block (%s) %d", log_info, block_number)
+        self.total_requested_bytes += end - start
+        self.miss_count += 1
+        block_contents = super()._fetch(start, end)
+        return block_contents
+
+    def _read_cache(
+        self, start: int, end: int, start_block_number: int, end_block_number: int
+    ) -> bytes:
+        """
+        Read from our block cache.
+
+        Parameters
+        ----------
+        start, end : int
+            The start and end byte positions.
+        start_block_number, end_block_number : int
+            The start and end block numbers.
+        """
+        start_pos = start % self.blocksize
+        end_pos = end % self.blocksize
+
+        # kind of pointless to count this as a hit, but it is
+        self.hit_count += 1
+
+        if start_block_number == end_block_number:
+            block = self._fetch_block_cached(start_block_number)
+            return block[start_pos:end_pos]
+
+        else:
+            # read from the initial
+            out = [self._fetch_block_cached(start_block_number)[start_pos:]]
+
+            # intermediate blocks
+            # Note: it'd be nice to combine these into one big request. However
+            # that doesn't play nicely with our LRU cache.
+            out.extend(
+                map(
+                    self._fetch_block_cached,
+                    range(start_block_number + 1, end_block_number),
+                )
+            )
+
+            # final block
+            out.append(self._fetch_block_cached(end_block_number)[:end_pos])
+
+            return b"".join(out)
+
+
+caches: dict[str | None, type[BaseCache]] = {
+    # one custom case
+    None: BaseCache,
+}
+
+
+def register_cache(cls: type[BaseCache], clobber: bool = False) -> None:
+    """'Register' cache implementation.
+
+    Parameters
+    ----------
+    clobber: bool, optional
+        If set to True (default is False) - allow to overwrite existing
+        entry.
+
+    Raises
+    ------
+    ValueError
+    """
+    name = cls.name
+    if not clobber and name in caches:
+        raise ValueError(f"Cache with name {name!r} is already known: {caches[name]}")
+    caches[name] = cls
+
+
+for c in (
+    BaseCache,
+    MMapCache,
+    BytesCache,
+    ReadAheadCache,
+    AdaptiveReadaheadCache,
+    BlockCache,
+    FirstChunkCache,
+    AllBytes,
+    KnownPartsOfAFile,
+    BackgroundBlockCache,
+):
+    register_cache(c)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/callbacks.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/callbacks.py
new file mode 100644
index 0000000000000000000000000000000000000000..7ca99ca6ac3cd69b28bcd1550f6550e8e648c5fe
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/callbacks.py
@@ -0,0 +1,324 @@
+from functools import wraps
+
+
+class Callback:
+    """
+    Base class and interface for callback mechanism
+
+    This class can be used directly for monitoring file transfers by
+    providing ``callback=Callback(hooks=...)`` (see the ``hooks`` argument,
+    below), or subclassed for more specialised behaviour.
+
+    Parameters
+    ----------
+    size: int (optional)
+        Nominal quantity for the value that corresponds to a complete
+        transfer, e.g., total number of tiles or total number of
+        bytes
+    value: int (0)
+        Starting internal counter value
+    hooks: dict or None
+        A dict of named functions to be called on each update. The signature
+        of these must be ``f(size, value, **kwargs)``
+    """
+
+    def __init__(self, size=None, value=0, hooks=None, **kwargs):
+        self.size = size
+        self.value = value
+        self.hooks = hooks or {}
+        self.kw = kwargs
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_args):
+        self.close()
+
+    def close(self):
+        """Close callback."""
+
+    def branched(self, path_1, path_2, **kwargs):
+        """
+        Return callback for child transfers
+
+        If this callback is operating at a higher level, e.g., put, which may
+        trigger transfers that can also be monitored. The function returns a callback
+        that has to be passed to the child method, e.g., put_file,
+        as `callback=` argument.
+
+        The implementation uses `callback.branch` for compatibility.
+        When implementing callbacks, it is recommended to override this function instead
+        of `branch` and avoid calling `super().branched(...)`.
+
+        Prefer using this function over `branch`.
+
+        Parameters
+        ----------
+        path_1: str
+            Child's source path
+        path_2: str
+            Child's destination path
+        **kwargs:
+            Arbitrary keyword arguments
+
+        Returns
+        -------
+        callback: Callback
+            A callback instance to be passed to the child method
+        """
+        self.branch(path_1, path_2, kwargs)
+        # mutate kwargs so that we can force the caller to pass "callback=" explicitly
+        return kwargs.pop("callback", DEFAULT_CALLBACK)
+
+    def branch_coro(self, fn):
+        """
+        Wraps a coroutine, and pass a new child callback to it.
+        """
+
+        @wraps(fn)
+        async def func(path1, path2: str, **kwargs):
+            with self.branched(path1, path2, **kwargs) as child:
+                return await fn(path1, path2, callback=child, **kwargs)
+
+        return func
+
+    def set_size(self, size):
+        """
+        Set the internal maximum size attribute
+
+        Usually called if not initially set at instantiation. Note that this
+        triggers a ``call()``.
+
+        Parameters
+        ----------
+        size: int
+        """
+        self.size = size
+        self.call()
+
+    def absolute_update(self, value):
+        """
+        Set the internal value state
+
+        Triggers ``call()``
+
+        Parameters
+        ----------
+        value: int
+        """
+        self.value = value
+        self.call()
+
+    def relative_update(self, inc=1):
+        """
+        Delta increment the internal counter
+
+        Triggers ``call()``
+
+        Parameters
+        ----------
+        inc: int
+        """
+        self.value += inc
+        self.call()
+
+    def call(self, hook_name=None, **kwargs):
+        """
+        Execute hook(s) with current state
+
+        Each function is passed the internal size and current value
+
+        Parameters
+        ----------
+        hook_name: str or None
+            If given, execute on this hook
+        kwargs: passed on to (all) hook(s)
+        """
+        if not self.hooks:
+            return
+        kw = self.kw.copy()
+        kw.update(kwargs)
+        if hook_name:
+            if hook_name not in self.hooks:
+                return
+            return self.hooks[hook_name](self.size, self.value, **kw)
+        for hook in self.hooks.values() or []:
+            hook(self.size, self.value, **kw)
+
+    def wrap(self, iterable):
+        """
+        Wrap an iterable to call ``relative_update`` on each iterations
+
+        Parameters
+        ----------
+        iterable: Iterable
+            The iterable that is being wrapped
+        """
+        for item in iterable:
+            self.relative_update()
+            yield item
+
+    def branch(self, path_1, path_2, kwargs):
+        """
+        Set callbacks for child transfers
+
+        If this callback is operating at a higher level, e.g., put, which may
+        trigger transfers that can also be monitored. The passed kwargs are
+        to be *mutated* to add ``callback=``, if this class supports branching
+        to children.
+
+        Parameters
+        ----------
+        path_1: str
+            Child's source path
+        path_2: str
+            Child's destination path
+        kwargs: dict
+            arguments passed to child method, e.g., put_file.
+
+        Returns
+        -------
+
+        """
+        return None
+
+    def no_op(self, *_, **__):
+        pass
+
+    def __getattr__(self, item):
+        """
+        If undefined methods are called on this class, nothing happens
+        """
+        return self.no_op
+
+    @classmethod
+    def as_callback(cls, maybe_callback=None):
+        """Transform callback=... into Callback instance
+
+        For the special value of ``None``, return the global instance of
+        ``NoOpCallback``. This is an alternative to including
+        ``callback=DEFAULT_CALLBACK`` directly in a method signature.
+        """
+        if maybe_callback is None:
+            return DEFAULT_CALLBACK
+        return maybe_callback
+
+
+class NoOpCallback(Callback):
+    """
+    This implementation of Callback does exactly nothing
+    """
+
+    def call(self, *args, **kwargs):
+        return None
+
+
+class DotPrinterCallback(Callback):
+    """
+    Simple example Callback implementation
+
+    Almost identical to Callback with a hook that prints a char; here we
+    demonstrate how the outer layer may print "#" and the inner layer "."
+    """
+
+    def __init__(self, chr_to_print="#", **kwargs):
+        self.chr = chr_to_print
+        super().__init__(**kwargs)
+
+    def branch(self, path_1, path_2, kwargs):
+        """Mutate kwargs to add new instance with different print char"""
+        kwargs["callback"] = DotPrinterCallback(".")
+
+    def call(self, **kwargs):
+        """Just outputs a character"""
+        print(self.chr, end="")
+
+
+class TqdmCallback(Callback):
+    """
+    A callback to display a progress bar using tqdm
+
+    Parameters
+    ----------
+    tqdm_kwargs : dict, (optional)
+        Any argument accepted by the tqdm constructor.
+        See the `tqdm doc <https://tqdm.github.io/docs/tqdm/#__init__>`_.
+        Will be forwarded to `tqdm_cls`.
+    tqdm_cls: (optional)
+        subclass of `tqdm.tqdm`. If not passed, it will default to `tqdm.tqdm`.
+
+    Examples
+    --------
+    >>> import fsspec
+    >>> from fsspec.callbacks import TqdmCallback
+    >>> fs = fsspec.filesystem("memory")
+    >>> path2distant_data = "/your-path"
+    >>> fs.upload(
+            ".",
+            path2distant_data,
+            recursive=True,
+            callback=TqdmCallback(),
+        )
+
+    You can forward args to tqdm using the ``tqdm_kwargs`` parameter.
+
+    >>> fs.upload(
+            ".",
+            path2distant_data,
+            recursive=True,
+            callback=TqdmCallback(tqdm_kwargs={"desc": "Your tqdm description"}),
+        )
+
+    You can also customize the progress bar by passing a subclass of `tqdm`.
+
+    .. code-block:: python
+
+        class TqdmFormat(tqdm):
+            '''Provides a `total_time` format parameter'''
+            @property
+            def format_dict(self):
+                d = super().format_dict
+                total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1)
+                d.update(total_time=self.format_interval(total_time) + " in total")
+                return d
+
+    >>> with TqdmCallback(
+            tqdm_kwargs={
+                "desc": "desc",
+                "bar_format": "{total_time}: {percentage:.0f}%|{bar}{r_bar}",
+            },
+            tqdm_cls=TqdmFormat,
+        ) as callback:
+            fs.upload(".", path2distant_data, recursive=True, callback=callback)
+    """
+
+    def __init__(self, tqdm_kwargs=None, *args, **kwargs):
+        try:
+            from tqdm import tqdm
+
+        except ImportError as exce:
+            raise ImportError(
+                "Using TqdmCallback requires tqdm to be installed"
+            ) from exce
+
+        self._tqdm_cls = kwargs.pop("tqdm_cls", tqdm)
+        self._tqdm_kwargs = tqdm_kwargs or {}
+        self.tqdm = None
+        super().__init__(*args, **kwargs)
+
+    def call(self, *args, **kwargs):
+        if self.tqdm is None:
+            self.tqdm = self._tqdm_cls(total=self.size, **self._tqdm_kwargs)
+        self.tqdm.total = self.size
+        self.tqdm.update(self.value - self.tqdm.n)
+
+    def close(self):
+        if self.tqdm is not None:
+            self.tqdm.close()
+            self.tqdm = None
+
+    def __del__(self):
+        return self.close()
+
+
+DEFAULT_CALLBACK = _DEFAULT_CALLBACK = NoOpCallback()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/compression.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/compression.py
new file mode 100644
index 0000000000000000000000000000000000000000..11c2e3d3f142d95186663fa5a747911e66832266
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/compression.py
@@ -0,0 +1,185 @@
+"""Helper functions for a standard streaming compression API"""
+
+import sys
+from zipfile import ZipFile
+
+import fsspec.utils
+from fsspec.spec import AbstractBufferedFile
+
+
+def noop_file(file, mode, **kwargs):
+    return file
+
+
+# TODO: files should also be available as contexts
+# should be functions of the form func(infile, mode=, **kwargs) -> file-like
+compr = {None: noop_file}
+
+
+def register_compression(name, callback, extensions, force=False):
+    """Register an "inferable" file compression type.
+
+    Registers transparent file compression type for use with fsspec.open.
+    Compression can be specified by name in open, or "infer"-ed for any files
+    ending with the given extensions.
+
+    Args:
+        name: (str) The compression type name. Eg. "gzip".
+        callback: A callable of form (infile, mode, **kwargs) -> file-like.
+            Accepts an input file-like object, the target mode and kwargs.
+            Returns a wrapped file-like object.
+        extensions: (str, Iterable[str]) A file extension, or list of file
+            extensions for which to infer this compression scheme. Eg. "gz".
+        force: (bool) Force re-registration of compression type or extensions.
+
+    Raises:
+        ValueError: If name or extensions already registered, and not force.
+
+    """
+    if isinstance(extensions, str):
+        extensions = [extensions]
+
+    # Validate registration
+    if name in compr and not force:
+        raise ValueError(f"Duplicate compression registration: {name}")
+
+    for ext in extensions:
+        if ext in fsspec.utils.compressions and not force:
+            raise ValueError(f"Duplicate compression file extension: {ext} ({name})")
+
+    compr[name] = callback
+
+    for ext in extensions:
+        fsspec.utils.compressions[ext] = name
+
+
+def unzip(infile, mode="rb", filename=None, **kwargs):
+    if "r" not in mode:
+        filename = filename or "file"
+        z = ZipFile(infile, mode="w", **kwargs)
+        fo = z.open(filename, mode="w")
+        fo.close = lambda closer=fo.close: closer() or z.close()
+        return fo
+    z = ZipFile(infile)
+    if filename is None:
+        filename = z.namelist()[0]
+    return z.open(filename, mode="r", **kwargs)
+
+
+register_compression("zip", unzip, "zip")
+
+try:
+    from bz2 import BZ2File
+except ImportError:
+    pass
+else:
+    register_compression("bz2", BZ2File, "bz2")
+
+try:  # pragma: no cover
+    from isal import igzip
+
+    def isal(infile, mode="rb", **kwargs):
+        return igzip.IGzipFile(fileobj=infile, mode=mode, **kwargs)
+
+    register_compression("gzip", isal, "gz")
+except ImportError:
+    from gzip import GzipFile
+
+    register_compression(
+        "gzip", lambda f, **kwargs: GzipFile(fileobj=f, **kwargs), "gz"
+    )
+
+try:
+    from lzma import LZMAFile
+
+    register_compression("lzma", LZMAFile, "lzma")
+    register_compression("xz", LZMAFile, "xz")
+except ImportError:
+    pass
+
+try:
+    import lzmaffi
+
+    register_compression("lzma", lzmaffi.LZMAFile, "lzma", force=True)
+    register_compression("xz", lzmaffi.LZMAFile, "xz", force=True)
+except ImportError:
+    pass
+
+
+class SnappyFile(AbstractBufferedFile):
+    def __init__(self, infile, mode, **kwargs):
+        import snappy
+
+        super().__init__(
+            fs=None, path="snappy", mode=mode.strip("b") + "b", size=999999999, **kwargs
+        )
+        self.infile = infile
+        if "r" in mode:
+            self.codec = snappy.StreamDecompressor()
+        else:
+            self.codec = snappy.StreamCompressor()
+
+    def _upload_chunk(self, final=False):
+        self.buffer.seek(0)
+        out = self.codec.add_chunk(self.buffer.read())
+        self.infile.write(out)
+        return True
+
+    def seek(self, loc, whence=0):
+        raise NotImplementedError("SnappyFile is not seekable")
+
+    def seekable(self):
+        return False
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        data = self.infile.read(end - start)
+        return self.codec.decompress(data)
+
+
+try:
+    import snappy
+
+    snappy.compress(b"")
+    # Snappy may use the .sz file extension, but this is not part of the
+    # standard implementation.
+    register_compression("snappy", SnappyFile, [])
+
+except (ImportError, NameError, AttributeError):
+    pass
+
+try:
+    import lz4.frame
+
+    register_compression("lz4", lz4.frame.open, "lz4")
+except ImportError:
+    pass
+
+try:
+    if sys.version_info >= (3, 14):
+        from compression import zstd
+    else:
+        from backports import zstd
+
+    register_compression("zstd", zstd.ZstdFile, "zst")
+except ImportError:
+    try:
+        import zstandard as zstd
+
+        def zstandard_file(infile, mode="rb"):
+            if "r" in mode:
+                cctx = zstd.ZstdDecompressor()
+                return cctx.stream_reader(infile)
+            else:
+                cctx = zstd.ZstdCompressor(level=10)
+                return cctx.stream_writer(infile)
+
+        register_compression("zstd", zstandard_file, "zst")
+    except ImportError:
+        pass
+    pass
+
+
+def available_compressions():
+    """Return a list of the implemented compressions."""
+    return list(compr)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/config.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/config.py
new file mode 100644
index 0000000000000000000000000000000000000000..19f68071ca026dc2bb11da70effb0c517de5380b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/config.py
@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import configparser
+import json
+import os
+import warnings
+from typing import Any
+
+conf: dict[str, dict[str, Any]] = {}
+default_conf_dir = os.path.join(os.path.expanduser("~"), ".config/fsspec")
+conf_dir = os.environ.get("FSSPEC_CONFIG_DIR", default_conf_dir)
+
+
+def set_conf_env(conf_dict, envdict=os.environ):
+    """Set config values from environment variables
+
+    Looks for variables of the form ``FSSPEC_<protocol>`` and
+    ``FSSPEC_<protocol>_<kwarg>``. For ``FSSPEC_<protocol>`` the value is parsed
+    as a json dictionary and used to ``update`` the config of the
+    corresponding protocol. For ``FSSPEC_<protocol>_<kwarg>`` there is no
+    attempt to convert the string value, but the kwarg keys will be lower-cased.
+
+    The ``FSSPEC_<protocol>_<kwarg>`` variables are applied after the
+    ``FSSPEC_<protocol>`` ones.
+
+    Parameters
+    ----------
+    conf_dict : dict(str, dict)
+        This dict will be mutated
+    envdict : dict-like(str, str)
+        Source for the values - usually the real environment
+    """
+    envdict = dict(envdict)
+    kwarg_keys = []
+    for key in envdict:
+        if key.startswith("FSSPEC_") and len(key) > 7 and key[7] != "_":
+            try:
+                value = json.loads(envdict[key])
+                envdict[key] = value
+            except json.decoder.JSONDecodeError:
+                value = envdict[key]
+            if key.count("_") > 1:
+                kwarg_keys.append(key)
+                continue
+            else:
+                if isinstance(value, dict):
+                    _, proto = key.split("_", 1)
+                    conf_dict.setdefault(proto.lower(), {}).update(value)
+                else:
+                    warnings.warn(
+                        f"Ignoring environment variable {key} due to not being a dict:"
+                        f" {type(value)}"
+                    )
+        elif key.startswith("FSSPEC"):
+            warnings.warn(
+                f"Ignoring environment variable {key} due to having an unexpected name"
+            )
+
+    for key in kwarg_keys:
+        _, proto, kwarg = key.split("_", 2)
+        conf_dict.setdefault(proto.lower(), {})[kwarg.lower()] = envdict[key]
+
+
+def set_conf_files(cdir, conf_dict):
+    """Set config values from files
+
+    Scans for INI and JSON files in the given dictionary, and uses their
+    contents to set the config. In case of repeated values, later values
+    win.
+
+    In the case of INI files, all values are strings, and these will not
+    be converted.
+
+    Parameters
+    ----------
+    cdir : str
+        Directory to search
+    conf_dict : dict(str, dict)
+        This dict will be mutated
+    """
+    if not os.path.isdir(cdir):
+        return
+    allfiles = sorted(os.listdir(cdir))
+    for fn in allfiles:
+        if fn.endswith(".ini"):
+            ini = configparser.ConfigParser()
+            ini.read(os.path.join(cdir, fn))
+            for key in ini:
+                if key == "DEFAULT":
+                    continue
+                conf_dict.setdefault(key, {}).update(dict(ini[key]))
+        if fn.endswith(".json"):
+            with open(os.path.join(cdir, fn)) as f:
+                js = json.load(f)
+            for key in js:
+                conf_dict.setdefault(key, {}).update(dict(js[key]))
+
+
+def apply_config(cls, kwargs, conf_dict=None):
+    """Supply default values for kwargs when instantiating class
+
+    Augments the passed kwargs, by finding entries in the config dict
+    which match the classes ``.protocol`` attribute (one or more str)
+
+    Parameters
+    ----------
+    cls : file system implementation
+    kwargs : dict
+    conf_dict : dict of dict
+        Typically this is the global configuration
+
+    Returns
+    -------
+    dict : the modified set of kwargs
+    """
+    if conf_dict is None:
+        conf_dict = conf
+    protos = cls.protocol if isinstance(cls.protocol, (tuple, list)) else [cls.protocol]
+    kw = {}
+    for proto in protos:
+        # default kwargs from the current state of the config
+        if proto in conf_dict:
+            kw.update(conf_dict[proto])
+    # explicit kwargs always win
+    kw.update(**kwargs)
+    kwargs = kw
+    return kwargs
+
+
+set_conf_files(conf_dir, conf)
+set_conf_env(conf)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/conftest.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/conftest.py
new file mode 100644
index 0000000000000000000000000000000000000000..f05eb5c30d42b0c1c5cc432f9c217d8f0e01f412
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/conftest.py
@@ -0,0 +1,125 @@
+import os
+import shutil
+import subprocess
+import sys
+import time
+from collections import deque
+from collections.abc import Generator, Sequence
+
+import pytest
+
+import fsspec
+
+
+@pytest.fixture()
+def m():
+    """
+    Fixture providing a memory filesystem.
+    """
+    m = fsspec.filesystem("memory")
+    m.store.clear()
+    m.pseudo_dirs.clear()
+    m.pseudo_dirs.append("")
+    try:
+        yield m
+    finally:
+        m.store.clear()
+        m.pseudo_dirs.clear()
+        m.pseudo_dirs.append("")
+
+
+class InstanceCacheInspector:
+    """
+    Helper class to inspect instance caches of filesystem classes in tests.
+    """
+
+    def clear(self) -> None:
+        """
+        Clear instance caches of all currently imported filesystem classes.
+        """
+        classes = deque([fsspec.spec.AbstractFileSystem])
+        while classes:
+            cls = classes.popleft()
+            cls.clear_instance_cache()
+            classes.extend(cls.__subclasses__())
+
+    def gather_counts(self, *, omit_zero: bool = True) -> dict[str, int]:
+        """
+        Gather counts of filesystem instances in the instance caches
+        of all currently imported filesystem classes.
+
+        Parameters
+        ----------
+        omit_zero:
+            Whether to omit instance types with no cached instances.
+        """
+        out: dict[str, int] = {}
+        classes = deque([fsspec.spec.AbstractFileSystem])
+        while classes:
+            cls = classes.popleft()
+            count = len(cls._cache)  # there is no public interface for the cache
+            # note: skip intermediate AbstractFileSystem subclasses
+            #   if they proxy the protocol attribute via a property.
+            if isinstance(cls.protocol, (Sequence, str)):
+                key = cls.protocol if isinstance(cls.protocol, str) else cls.protocol[0]
+                if count or not omit_zero:
+                    out[key] = count
+            classes.extend(cls.__subclasses__())
+        return out
+
+
+@pytest.fixture(scope="function", autouse=True)
+def instance_caches() -> Generator[InstanceCacheInspector, None, None]:
+    """
+    Fixture to ensure empty filesystem instance caches before and after a test.
+
+    Used by default for all tests.
+    Clears caches of all imported filesystem classes.
+    Can be used to write test assertions about instance caches.
+
+    Usage:
+
+        def test_something(instance_caches):
+            # Test code here
+            fsspec.open("file://abc")
+            fsspec.open("memory://foo/bar")
+
+            # Test assertion
+            assert instance_caches.gather_counts() == {"file": 1, "memory": 1}
+
+    Returns
+    -------
+    instance_caches: An instance cache inspector for clearing and inspecting caches.
+    """
+    ic = InstanceCacheInspector()
+
+    ic.clear()
+    try:
+        yield ic
+    finally:
+        ic.clear()
+
+
+@pytest.fixture(scope="function")
+def ftp_writable(tmpdir):
+    """
+    Fixture providing a writable FTP filesystem.
+    """
+    pytest.importorskip("pyftpdlib")
+
+    d = str(tmpdir)
+    with open(os.path.join(d, "out"), "wb") as f:
+        f.write(b"hello" * 10000)
+    P = subprocess.Popen(
+        [sys.executable, "-m", "pyftpdlib", "-d", d, "-u", "user", "-P", "pass", "-w"]
+    )
+    try:
+        time.sleep(1)
+        yield "localhost", 2121, "user", "pass"
+    finally:
+        P.terminate()
+        P.wait()
+        try:
+            shutil.rmtree(tmpdir)
+        except Exception:
+            pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/core.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/core.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1e7e7bbd0639e3607647b1cfe486405ce45c375
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/core.py
@@ -0,0 +1,765 @@
+from __future__ import annotations
+
+import io
+import logging
+import posixpath
+import re
+from glob import has_magic
+from pathlib import Path
+
+# for backwards compat, we export cache things from here too
+from fsspec.caching import (  # noqa: F401
+    BaseCache,
+    BlockCache,
+    BytesCache,
+    MMapCache,
+    ReadAheadCache,
+    caches,
+)
+from fsspec.compression import compr
+from fsspec.config import conf
+from fsspec.registry import available_protocols, filesystem, get_filesystem_class
+from fsspec.utils import (
+    _unstrip_protocol,
+    build_name_function,
+    infer_compression,
+    stringify_path,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+class OpenFile:
+    """
+    File-like object to be used in a context
+
+    Can layer (buffered) text-mode and compression over any file-system, which
+    are typically binary-only.
+
+    These instances are safe to serialize, as the low-level file object
+    is not created until invoked using ``with``.
+
+    Parameters
+    ----------
+    fs: FileSystem
+        The file system to use for opening the file. Should be a subclass or duck-type
+        with ``fsspec.spec.AbstractFileSystem``
+    path: str
+        Location to open
+    mode: str like 'rb', optional
+        Mode of the opened file
+    compression: str or None, optional
+        Compression to apply
+    encoding: str or None, optional
+        The encoding to use if opened in text mode.
+    errors: str or None, optional
+        How to handle encoding errors if opened in text mode.
+    newline: None or str
+        Passed to TextIOWrapper in text mode, how to handle line endings.
+    autoopen: bool
+        If True, calls open() immediately. Mostly used by pickle
+    pos: int
+        If given and autoopen is True, seek to this location immediately
+    """
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        compression=None,
+        encoding=None,
+        errors=None,
+        newline=None,
+    ):
+        self.fs = fs
+        self.path = path
+        self.mode = mode
+        self.compression = get_compression(path, compression)
+        self.encoding = encoding
+        self.errors = errors
+        self.newline = newline
+        self.fobjects = []
+
+    def __reduce__(self):
+        return (
+            OpenFile,
+            (
+                self.fs,
+                self.path,
+                self.mode,
+                self.compression,
+                self.encoding,
+                self.errors,
+                self.newline,
+            ),
+        )
+
+    def __repr__(self):
+        return f"<OpenFile '{self.path}'>"
+
+    def __enter__(self):
+        mode = self.mode.replace("t", "").replace("b", "") + "b"
+
+        try:
+            f = self.fs.open(self.path, mode=mode)
+        except FileNotFoundError as e:
+            if has_magic(self.path):
+                raise FileNotFoundError(
+                    "%s not found. The URL contains glob characters: you maybe needed\n"
+                    "to pass expand=True in fsspec.open() or the storage_options of \n"
+                    "your library. You can also set the config value 'open_expand'\n"
+                    "before import, or fsspec.core.DEFAULT_EXPAND at runtime, to True.",
+                    self.path,
+                ) from e
+            raise
+
+        self.fobjects = [f]
+
+        if self.compression is not None:
+            compress = compr[self.compression]
+            f = compress(f, mode=mode[0])
+            self.fobjects.append(f)
+
+        if "b" not in self.mode:
+            # assume, for example, that 'r' is equivalent to 'rt' as in builtin
+            f = PickleableTextIOWrapper(
+                f, encoding=self.encoding, errors=self.errors, newline=self.newline
+            )
+            self.fobjects.append(f)
+
+        return self.fobjects[-1]
+
+    def __exit__(self, *args):
+        self.close()
+
+    @property
+    def full_name(self):
+        return _unstrip_protocol(self.path, self.fs)
+
+    def open(self):
+        """Materialise this as a real open file without context
+
+        The OpenFile object should be explicitly closed to avoid enclosed file
+        instances persisting. You must, therefore, keep a reference to the OpenFile
+        during the life of the file-like it generates.
+        """
+        return self.__enter__()
+
+    def close(self):
+        """Close all encapsulated file objects"""
+        for f in reversed(self.fobjects):
+            if "r" not in self.mode and not f.closed:
+                f.flush()
+            f.close()
+        self.fobjects.clear()
+
+
+class OpenFiles(list):
+    """List of OpenFile instances
+
+    Can be used in a single context, which opens and closes all of the
+    contained files. Normal list access to get the elements works as
+    normal.
+
+    A special case is made for caching filesystems - the files will
+    be down/uploaded together at the start or end of the context, and
+    this may happen concurrently, if the target filesystem supports it.
+    """
+
+    def __init__(self, *args, mode="rb", fs=None):
+        self.mode = mode
+        self.fs = fs
+        self.files = []
+        super().__init__(*args)
+
+    def __enter__(self):
+        if self.fs is None:
+            raise ValueError("Context has already been used")
+
+        fs = self.fs
+        while True:
+            if hasattr(fs, "open_many"):
+                # check for concurrent cache download; or set up for upload
+                self.files = fs.open_many(self)
+                return self.files
+            if hasattr(fs, "fs") and fs.fs is not None:
+                fs = fs.fs
+            else:
+                break
+        return [s.__enter__() for s in self]
+
+    def __exit__(self, *args):
+        fs = self.fs
+        [s.__exit__(*args) for s in self]
+        if "r" in self.mode:
+            # open_many() returns files without populating the OpenFile objects.
+            for f in self.files:
+                f.close()
+        else:
+            while True:
+                if hasattr(fs, "open_many"):
+                    # check for concurrent cache upload
+                    fs.commit_many(self.files)
+                    return
+                if hasattr(fs, "fs") and fs.fs is not None:
+                    fs = fs.fs
+                else:
+                    break
+
+    def __getitem__(self, item):
+        out = super().__getitem__(item)
+        if isinstance(item, slice):
+            return OpenFiles(out, mode=self.mode, fs=self.fs)
+        return out
+
+    def __repr__(self):
+        return f"<List of {len(self)} OpenFile instances>"
+
+
+def open_files(
+    urlpath,
+    mode="rb",
+    compression=None,
+    encoding="utf8",
+    errors=None,
+    name_function=None,
+    num=1,
+    protocol=None,
+    newline=None,
+    auto_mkdir=True,
+    expand=True,
+    **kwargs,
+):
+    """Given a path or paths, return a list of ``OpenFile`` objects.
+
+    For writing, a str path must contain the "*" character, which will be filled
+    in by increasing numbers, e.g., "part*" ->  "part1", "part2" if num=2.
+
+    For either reading or writing, can instead provide explicit list of paths.
+
+    Parameters
+    ----------
+    urlpath: string or list
+        Absolute or relative filepath(s). Prefix with a protocol like ``s3://``
+        to read from alternative filesystems. To read from multiple files you
+        can pass a globstring or a list of paths, with the caveat that they
+        must all have the same protocol.
+    mode: 'rb', 'wt', etc.
+    compression: string or None
+        If given, open file using compression codec. Can either be a compression
+        name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+        compression from the filename suffix.
+    encoding: str
+        For text mode only
+    errors: None or str
+        Passed to TextIOWrapper in text mode
+    name_function: function or None
+        if opening a set of files for writing, those files do not yet exist,
+        so we need to generate their names by formatting the urlpath for
+        each sequence number
+    num: int [1]
+        if writing mode, number of files we expect to create (passed to
+        name+function)
+    protocol: str or None
+        If given, overrides the protocol found in the URL.
+    newline: bytes or None
+        Used for line terminator in text mode. If None, uses system default;
+        if blank, uses no translation.
+    auto_mkdir: bool (True)
+        If in write mode, this will ensure the target directory exists before
+        writing, by calling ``fs.mkdirs(exist_ok=True)``.
+    expand: bool
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Examples
+    --------
+    >>> files = open_files('2015-*-*.csv')  # doctest: +SKIP
+    >>> files = open_files(
+    ...     's3://bucket/2015-*-*.csv.gz', compression='gzip'
+    ... )  # doctest: +SKIP
+
+    Returns
+    -------
+    An ``OpenFiles`` instance, which is a list of ``OpenFile`` objects that can
+    be used as a single context
+
+    Notes
+    -----
+    For a full list of the available protocols and the implementations that
+    they map across to see the latest online documentation:
+
+    - For implementations built into ``fsspec`` see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+    - For implementations in separate packages see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+    """
+    fs, fs_token, paths = get_fs_token_paths(
+        urlpath,
+        mode,
+        num=num,
+        name_function=name_function,
+        storage_options=kwargs,
+        protocol=protocol,
+        expand=expand,
+    )
+    if fs.protocol == "file":
+        fs.auto_mkdir = auto_mkdir
+    elif "r" not in mode and auto_mkdir:
+        parents = {fs._parent(path) for path in paths}
+        for parent in parents:
+            try:
+                fs.makedirs(parent, exist_ok=True)
+            except PermissionError:
+                pass
+    return OpenFiles(
+        [
+            OpenFile(
+                fs,
+                path,
+                mode=mode,
+                compression=compression,
+                encoding=encoding,
+                errors=errors,
+                newline=newline,
+            )
+            for path in paths
+        ],
+        mode=mode,
+        fs=fs,
+    )
+
+
+def _un_chain(path, kwargs):
+    # Avoid a circular import
+    from fsspec.implementations.chained import ChainedFileSystem
+
+    if "::" in path:
+        x = re.compile(".*[^a-z]+.*")  # test for non protocol-like single word
+        known_protocols = set(available_protocols())
+        bits = []
+
+        # split on '::', then ensure each bit has a protocol
+        for p in path.split("::"):
+            if p in known_protocols:
+                bits.append(p + "://")
+            elif "://" in p or x.match(p):
+                bits.append(p)
+            else:
+                bits.append(p + "://")
+    else:
+        bits = [path]
+
+    # [[url, protocol, kwargs], ...]
+    out = []
+    previous_bit = None
+    kwargs = kwargs.copy()
+
+    for bit in reversed(bits):
+        protocol = kwargs.pop("protocol", None) or split_protocol(bit)[0] or "file"
+        cls = get_filesystem_class(protocol)
+        extra_kwargs = cls._get_kwargs_from_urls(bit)
+        kws = kwargs.pop(protocol, {})
+
+        if bit is bits[0]:
+            kws.update(kwargs)
+
+        kw = dict(
+            **{k: v for k, v in extra_kwargs.items() if k not in kws or v != kws[k]},
+            **kws,
+        )
+        bit = cls._strip_protocol(bit)
+
+        if (
+            "target_protocol" not in kw
+            and issubclass(cls, ChainedFileSystem)
+            and not bit
+        ):
+            # replace bit if we are chaining and no path given
+            bit = previous_bit
+
+        out.append((bit, protocol, kw))
+        previous_bit = bit
+
+    out.reverse()
+    return out
+
+
+def url_to_fs(url, **kwargs):
+    """
+    Turn fully-qualified and potentially chained URL into filesystem instance
+
+    Parameters
+    ----------
+    url : str
+        The fsspec-compatible URL
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Returns
+    -------
+    filesystem : FileSystem
+        The new filesystem discovered from ``url`` and created with
+        ``**kwargs``.
+    urlpath : str
+        The file-systems-specific URL for ``url``.
+    """
+    url = stringify_path(url)
+    # non-FS arguments that appear in fsspec.open()
+    # inspect could keep this in sync with open()'s signature
+    known_kwargs = {
+        "compression",
+        "encoding",
+        "errors",
+        "expand",
+        "mode",
+        "name_function",
+        "newline",
+        "num",
+    }
+    kwargs = {k: v for k, v in kwargs.items() if k not in known_kwargs}
+    chain = _un_chain(url, kwargs)
+    inkwargs = {}
+    # Reverse iterate the chain, creating a nested target_* structure
+    for i, ch in enumerate(reversed(chain)):
+        urls, protocol, kw = ch
+        if i == len(chain) - 1:
+            inkwargs = dict(**kw, **inkwargs)
+            continue
+        inkwargs["target_options"] = dict(**kw, **inkwargs)
+        inkwargs["target_protocol"] = protocol
+        inkwargs["fo"] = urls
+    urlpath, protocol, _ = chain[0]
+    fs = filesystem(protocol, **inkwargs)
+    return fs, urlpath
+
+
+DEFAULT_EXPAND = conf.get("open_expand", False)
+
+
+def open(
+    urlpath,
+    mode="rb",
+    compression=None,
+    encoding="utf8",
+    errors=None,
+    protocol=None,
+    newline=None,
+    expand=None,
+    **kwargs,
+):
+    """Given a path or paths, return one ``OpenFile`` object.
+
+    Parameters
+    ----------
+    urlpath: string or list
+        Absolute or relative filepath. Prefix with a protocol like ``s3://``
+        to read from alternative filesystems. Should not include glob
+        character(s).
+    mode: 'rb', 'wt', etc.
+    compression: string or None
+        If given, open file using compression codec. Can either be a compression
+        name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+        compression from the filename suffix.
+    encoding: str
+        For text mode only
+    errors: None or str
+        Passed to TextIOWrapper in text mode
+    protocol: str or None
+        If given, overrides the protocol found in the URL.
+    newline: bytes or None
+        Used for line terminator in text mode. If None, uses system default;
+        if blank, uses no translation.
+    expand: bool or None
+        Whether to regard file paths containing special glob characters as needing
+        expansion (finding the first match) or absolute. Setting False allows using
+        paths which do embed such characters. If None (default), this argument
+        takes its value from the DEFAULT_EXPAND module variable, which takes
+        its initial value from the "open_expand" config value at startup, which will
+        be False if not set.
+    **kwargs: dict
+        Extra options that make sense to a particular storage connection, e.g.
+        host, port, username, password, etc.
+
+    Examples
+    --------
+    >>> openfile = open('2015-01-01.csv')  # doctest: +SKIP
+    >>> openfile = open(
+    ...     's3://bucket/2015-01-01.csv.gz', compression='gzip'
+    ... )  # doctest: +SKIP
+    >>> with openfile as f:
+    ...     df = pd.read_csv(f)  # doctest: +SKIP
+    ...
+
+    Returns
+    -------
+    ``OpenFile`` object.
+
+    Notes
+    -----
+    For a full list of the available protocols and the implementations that
+    they map across to see the latest online documentation:
+
+    - For implementations built into ``fsspec`` see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#built-in-implementations
+    - For implementations in separate packages see
+      https://filesystem-spec.readthedocs.io/en/latest/api.html#other-known-implementations
+    """
+    expand = DEFAULT_EXPAND if expand is None else expand
+    out = open_files(
+        urlpath=[urlpath],
+        mode=mode,
+        compression=compression,
+        encoding=encoding,
+        errors=errors,
+        protocol=protocol,
+        newline=newline,
+        expand=expand,
+        **kwargs,
+    )
+    if not out:
+        raise FileNotFoundError(urlpath)
+    return out[0]
+
+
+def open_local(
+    url: str | list[str] | Path | list[Path],
+    mode: str = "rb",
+    **storage_options: dict,
+) -> str | list[str]:
+    """Open file(s) which can be resolved to local
+
+    For files which either are local, or get downloaded upon open
+    (e.g., by file caching)
+
+    Parameters
+    ----------
+    url: str or list(str)
+    mode: str
+        Must be read mode
+    storage_options:
+        passed on to FS for or used by open_files (e.g., compression)
+    """
+    if "r" not in mode:
+        raise ValueError("Can only ensure local files when reading")
+    of = open_files(url, mode=mode, **storage_options)
+    if not getattr(of[0].fs, "local_file", False):
+        raise ValueError(
+            "open_local can only be used on a filesystem which"
+            " has attribute local_file=True"
+        )
+    with of as files:
+        paths = [f.name for f in files]
+    if (isinstance(url, str) and not has_magic(url)) or isinstance(url, Path):
+        return paths[0]
+    return paths
+
+
+def get_compression(urlpath, compression):
+    if compression == "infer":
+        compression = infer_compression(urlpath)
+    if compression is not None and compression not in compr:
+        raise ValueError(f"Compression type {compression} not supported")
+    return compression
+
+
+def split_protocol(urlpath):
+    """Return protocol, path pair"""
+    urlpath = stringify_path(urlpath)
+    if "://" in urlpath:
+        protocol, path = urlpath.split("://", 1)
+        if len(protocol) > 1:
+            # excludes Windows paths
+            return protocol, path
+    if urlpath.startswith("data:"):
+        return urlpath.split(":", 1)
+    return None, urlpath
+
+
+def strip_protocol(urlpath):
+    """Return only path part of full URL, according to appropriate backend"""
+    protocol, _ = split_protocol(urlpath)
+    cls = get_filesystem_class(protocol)
+    return cls._strip_protocol(urlpath)
+
+
+def expand_paths_if_needed(paths, mode, num, fs, name_function):
+    """Expand paths if they have a ``*`` in them (write mode) or any of ``*?[]``
+    in them (read mode).
+
+    :param paths: list of paths
+    mode: str
+        Mode in which to open files.
+    num: int
+        If opening in writing mode, number of files we expect to create.
+    fs: filesystem object
+    name_function: callable
+        If opening in writing mode, this callable is used to generate path
+        names. Names are generated for each partition by
+        ``urlpath.replace('*', name_function(partition_index))``.
+    :return: list of paths
+    """
+    expanded_paths = []
+    paths = list(paths)
+
+    if "w" in mode or "x" in mode:  # write mode
+        if sum(1 for p in paths if "*" in p) > 1:
+            raise ValueError(
+                "When writing data, only one filename mask can be specified."
+            )
+        num = max(num, len(paths))
+
+        for curr_path in paths:
+            if "*" in curr_path:
+                # expand using name_function
+                expanded_paths.extend(_expand_paths(curr_path, name_function, num))
+            else:
+                expanded_paths.append(curr_path)
+        # if we generated more paths that asked for, trim the list
+        if len(expanded_paths) > num:
+            expanded_paths = expanded_paths[:num]
+
+    else:  # read mode
+        for curr_path in paths:
+            if has_magic(curr_path):
+                # expand using glob
+                expanded_paths.extend(fs.glob(curr_path))
+            else:
+                expanded_paths.append(curr_path)
+
+    return expanded_paths
+
+
+def get_fs_token_paths(
+    urlpath,
+    mode="rb",
+    num=1,
+    name_function=None,
+    storage_options=None,
+    protocol=None,
+    expand=True,
+):
+    """Filesystem, deterministic token, and paths from a urlpath and options.
+
+    Parameters
+    ----------
+    urlpath: string or iterable
+        Absolute or relative filepath, URL (may include protocols like
+        ``s3://``), or globstring pointing to data.
+    mode: str, optional
+        Mode in which to open files.
+    num: int, optional
+        If opening in writing mode, number of files we expect to create.
+    name_function: callable, optional
+        If opening in writing mode, this callable is used to generate path
+        names. Names are generated for each partition by
+        ``urlpath.replace('*', name_function(partition_index))``.
+    storage_options: dict, optional
+        Additional keywords to pass to the filesystem class.
+    protocol: str or None
+        To override the protocol specifier in the URL
+    expand: bool
+        Expand string paths for writing, assuming the path is a directory
+    """
+    if isinstance(urlpath, (list, tuple, set)):
+        if not urlpath:
+            raise ValueError("empty urlpath sequence")
+        urlpath0 = stringify_path(next(iter(urlpath)))
+    else:
+        urlpath0 = stringify_path(urlpath)
+    storage_options = storage_options or {}
+    if protocol:
+        storage_options["protocol"] = protocol
+    chain = _un_chain(urlpath0, storage_options or {})
+    inkwargs = {}
+    # Reverse iterate the chain, creating a nested target_* structure
+    for i, ch in enumerate(reversed(chain)):
+        urls, nested_protocol, kw = ch
+        if i == len(chain) - 1:
+            inkwargs = dict(**kw, **inkwargs)
+            continue
+        inkwargs["target_options"] = dict(**kw, **inkwargs)
+        inkwargs["target_protocol"] = nested_protocol
+        inkwargs["fo"] = urls
+    paths, protocol, _ = chain[0]
+    fs = filesystem(protocol, **inkwargs)
+    if isinstance(urlpath, (list, tuple, set)):
+        pchains = [
+            _un_chain(stringify_path(u), storage_options or {})[0] for u in urlpath
+        ]
+        if len({pc[1] for pc in pchains}) > 1:
+            raise ValueError("Protocol mismatch getting fs from %s", urlpath)
+        paths = [pc[0] for pc in pchains]
+    else:
+        paths = fs._strip_protocol(paths)
+    if isinstance(paths, (list, tuple, set)):
+        if expand:
+            paths = expand_paths_if_needed(paths, mode, num, fs, name_function)
+        elif not isinstance(paths, list):
+            paths = list(paths)
+    else:
+        if ("w" in mode or "x" in mode) and expand:
+            paths = _expand_paths(paths, name_function, num)
+        elif "*" in paths:
+            paths = [f for f in sorted(fs.glob(paths)) if not fs.isdir(f)]
+        else:
+            paths = [paths]
+
+    return fs, fs._fs_token, paths
+
+
+def _expand_paths(path, name_function, num):
+    if isinstance(path, str):
+        if path.count("*") > 1:
+            raise ValueError("Output path spec must contain exactly one '*'.")
+        elif "*" not in path:
+            # paths are "/"-separated on every filesystem, including local ones
+            path = posixpath.join(path, "*.part")
+
+        if name_function is None:
+            name_function = build_name_function(num - 1)
+
+        paths = [path.replace("*", name_function(i)) for i in range(num)]
+        if paths != sorted(paths):
+            logger.warning(
+                "In order to preserve order between partitions"
+                " paths created with ``name_function`` should "
+                "sort to partition order"
+            )
+    elif isinstance(path, (tuple, list)):
+        assert len(path) == num
+        paths = list(path)
+    else:
+        raise ValueError(
+            "Path should be either\n"
+            "1. A list of paths: ['foo.json', 'bar.json', ...]\n"
+            "2. A directory: 'foo/\n"
+            "3. A path with a '*' in it: 'foo.*.json'"
+        )
+    return paths
+
+
+class PickleableTextIOWrapper(io.TextIOWrapper):
+    """TextIOWrapper cannot be pickled. This solves it.
+
+    Requires that ``buffer`` be pickleable, which all instances of
+    AbstractBufferedFile are.
+    """
+
+    def __init__(
+        self,
+        buffer,
+        encoding=None,
+        errors=None,
+        newline=None,
+        line_buffering=False,
+        write_through=False,
+    ):
+        self.args = buffer, encoding, errors, newline, line_buffering, write_through
+        super().__init__(*self.args)
+
+    def __reduce__(self):
+        return PickleableTextIOWrapper, self.args
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/dircache.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/dircache.py
new file mode 100644
index 0000000000000000000000000000000000000000..eca19566b135e5a7a4f6e7407d56411ec58bfe44
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/dircache.py
@@ -0,0 +1,98 @@
+import time
+from collections.abc import MutableMapping
+from functools import lru_cache
+
+
+class DirCache(MutableMapping):
+    """
+    Caching of directory listings, in a structure like::
+
+        {"path0": [
+            {"name": "path0/file0",
+             "size": 123,
+             "type": "file",
+             ...
+            },
+            {"name": "path0/file1",
+            },
+            ...
+            ],
+         "path1": [...]
+        }
+
+    Parameters to this class control listing expiry or indeed turn
+    caching off
+    """
+
+    def __init__(
+        self,
+        use_listings_cache=True,
+        listings_expiry_time=None,
+        max_paths=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        use_listings_cache: bool
+            If False, this cache never returns items, but always reports KeyError,
+            and setting items has no effect
+        listings_expiry_time: int or float (optional)
+            Time in seconds that a listing is considered valid. If None,
+            listings do not expire.
+        max_paths: int (optional)
+            The number of most recent listings that are considered valid; 'recent'
+            refers to when the entry was set.
+        """
+        self._cache = {}
+        self._times = {}
+        if max_paths:
+            self._q = lru_cache(max_paths + 1)(lambda key: self._cache.pop(key, None))
+        self.use_listings_cache = use_listings_cache
+        self.listings_expiry_time = listings_expiry_time
+        self.max_paths = max_paths
+
+    def __getitem__(self, item):
+        if self.listings_expiry_time is not None:
+            if self._times.get(item, 0) - time.time() < -self.listings_expiry_time:
+                del self._cache[item]
+        if self.max_paths:
+            self._q(item)
+        return self._cache[item]  # maybe raises KeyError
+
+    def clear(self):
+        self._cache.clear()
+
+    def __len__(self):
+        return len(self._cache)
+
+    def __contains__(self, item):
+        try:
+            self[item]
+            return True
+        except KeyError:
+            return False
+
+    def __setitem__(self, key, value):
+        if not self.use_listings_cache:
+            return
+        if self.max_paths:
+            self._q(key)
+        self._cache[key] = value
+        if self.listings_expiry_time is not None:
+            self._times[key] = time.time()
+
+    def __delitem__(self, key):
+        del self._cache[key]
+
+    def __iter__(self):
+        entries = list(self._cache)
+
+        return (k for k in entries if k in self)
+
+    def __reduce__(self):
+        return (
+            DirCache,
+            (self.use_listings_cache, self.listings_expiry_time, self.max_paths),
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae8905475f02655f4fc5863931d99ca9da55db78
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/exceptions.py
@@ -0,0 +1,18 @@
+"""
+fsspec user-defined exception classes
+"""
+
+import asyncio
+
+
+class BlocksizeMismatchError(ValueError):
+    """
+    Raised when a cached file is opened with a different blocksize than it was
+    written with
+    """
+
+
+class FSTimeoutError(asyncio.TimeoutError):
+    """
+    Raised when a fsspec function timed out occurs
+    """
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/fuse.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/fuse.py
new file mode 100644
index 0000000000000000000000000000000000000000..566d520fce3e94e3bbaee48c3c6acc9f1db315a8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/fuse.py
@@ -0,0 +1,324 @@
+import argparse
+import logging
+import os
+import stat
+import threading
+import time
+from errno import EIO, ENOENT
+
+from fuse import FUSE, FuseOSError, LoggingMixIn, Operations
+
+from fsspec import __version__
+from fsspec.core import url_to_fs
+
+logger = logging.getLogger("fsspec.fuse")
+
+
+class FUSEr(Operations):
+    def __init__(self, fs, path, ready_file=False):
+        self.fs = fs
+        self.cache = {}
+        self.root = path.rstrip("/") + "/"
+        self.counter = 0
+        logger.info("Starting FUSE at %s", path)
+        self._ready_file = ready_file
+
+    def getattr(self, path, fh=None):
+        logger.debug("getattr %s", path)
+        if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+            return {"type": "file", "st_size": 5}
+
+        path = "".join([self.root, path.lstrip("/")]).rstrip("/")
+        try:
+            info = self.fs.info(path)
+        except FileNotFoundError as exc:
+            raise FuseOSError(ENOENT) from exc
+
+        data = {"st_uid": info.get("uid", 1000), "st_gid": info.get("gid", 1000)}
+        perm = info.get("mode", 0o777)
+
+        if info["type"] != "file":
+            data["st_mode"] = stat.S_IFDIR | perm
+            data["st_size"] = 0
+            data["st_blksize"] = 0
+        else:
+            data["st_mode"] = stat.S_IFREG | perm
+            data["st_size"] = info["size"]
+            data["st_blksize"] = 5 * 2**20
+            data["st_nlink"] = 1
+        data["st_atime"] = info["atime"] if "atime" in info else time.time()
+        data["st_ctime"] = info["ctime"] if "ctime" in info else time.time()
+        data["st_mtime"] = info["mtime"] if "mtime" in info else time.time()
+        return data
+
+    def readdir(self, path, fh):
+        logger.debug("readdir %s", path)
+        path = "".join([self.root, path.lstrip("/")])
+        files = self.fs.ls(path, False)
+        files = [os.path.basename(f.rstrip("/")) for f in files]
+        return [".", ".."] + files
+
+    def mkdir(self, path, mode):
+        path = "".join([self.root, path.lstrip("/")])
+        self.fs.mkdir(path)
+        return 0
+
+    def rmdir(self, path):
+        path = "".join([self.root, path.lstrip("/")])
+        self.fs.rmdir(path)
+        return 0
+
+    def read(self, path, size, offset, fh):
+        logger.debug("read %s", (path, size, offset))
+        if self._ready_file and path in ["/.fuse_ready", ".fuse_ready"]:
+            # status indicator
+            return b"ready"
+
+        f = self.cache[fh]
+        f.seek(offset)
+        out = f.read(size)
+        return out
+
+    def write(self, path, data, offset, fh):
+        logger.debug("write %s", (path, offset))
+        f = self.cache[fh]
+        f.seek(offset)
+        f.write(data)
+        return len(data)
+
+    def create(self, path, flags, fi=None):
+        logger.debug("create %s", (path, flags))
+        fn = "".join([self.root, path.lstrip("/")])
+        self.fs.touch(fn)  # OS will want to get attributes immediately
+        f = self.fs.open(fn, "wb")
+        self.cache[self.counter] = f
+        self.counter += 1
+        return self.counter - 1
+
+    def open(self, path, flags):
+        logger.debug("open %s", (path, flags))
+        fn = "".join([self.root, path.lstrip("/")])
+        if flags % 2 == 0:
+            # read
+            mode = "rb"
+        else:
+            # write/create
+            mode = "wb"
+        self.cache[self.counter] = self.fs.open(fn, mode)
+        self.counter += 1
+        return self.counter - 1
+
+    def truncate(self, path, length, fh=None):
+        fn = "".join([self.root, path.lstrip("/")])
+        if length != 0:
+            raise NotImplementedError
+        # maybe should be no-op since open with write sets size to zero anyway
+        self.fs.touch(fn)
+
+    def unlink(self, path):
+        fn = "".join([self.root, path.lstrip("/")])
+        try:
+            self.fs.rm(fn, False)
+        except (OSError, FileNotFoundError) as exc:
+            raise FuseOSError(EIO) from exc
+
+    def release(self, path, fh):
+        try:
+            if fh in self.cache:
+                f = self.cache[fh]
+                f.close()
+                self.cache.pop(fh)
+        except Exception as e:
+            print(e)
+        return 0
+
+    def chmod(self, path, mode):
+        if hasattr(self.fs, "chmod"):
+            path = "".join([self.root, path.lstrip("/")])
+            return self.fs.chmod(path, mode)
+        raise NotImplementedError
+
+
+def run(
+    fs,
+    path,
+    mount_point,
+    foreground=True,
+    threads=False,
+    ready_file=False,
+    ops_class=FUSEr,
+):
+    """Mount stuff in a local directory
+
+    This uses fusepy to make it appear as if a given path on an fsspec
+    instance is in fact resident within the local file-system.
+
+    This requires that fusepy by installed, and that FUSE be available on
+    the system (typically requiring a package to be installed with
+    apt, yum, brew, etc.).
+
+    Parameters
+    ----------
+    fs: file-system instance
+        From one of the compatible implementations
+    path: str
+        Location on that file-system to regard as the root directory to
+        mount. Note that you typically should include the terminating "/"
+        character.
+    mount_point: str
+        An empty directory on the local file-system where the contents of
+        the remote path will appear.
+    foreground: bool
+        Whether or not calling this function will block. Operation will
+        typically be more stable if True.
+    threads: bool
+        Whether or not to create threads when responding to file operations
+        within the mounter directory. Operation will typically be more
+        stable if False.
+    ready_file: bool
+        Whether the FUSE process is ready. The ``.fuse_ready`` file will
+        exist in the ``mount_point`` directory if True. Debugging purpose.
+    ops_class: FUSEr or Subclass of FUSEr
+        To override the default behavior of FUSEr. For Example, logging
+        to file.
+
+    """
+    func = lambda: FUSE(
+        ops_class(fs, path, ready_file=ready_file),
+        mount_point,
+        nothreads=not threads,
+        foreground=foreground,
+    )
+    if not foreground:
+        th = threading.Thread(target=func)
+        th.daemon = True
+        th.start()
+        return th
+    else:  # pragma: no cover
+        try:
+            func()
+        except KeyboardInterrupt:
+            pass
+
+
+def main(args):
+    """Mount filesystem from chained URL to MOUNT_POINT.
+
+    Examples:
+
+    python3 -m fsspec.fuse memory /usr/share /tmp/mem
+
+    python3 -m fsspec.fuse local /tmp/source /tmp/local \\
+            -l /tmp/fsspecfuse.log
+
+    You can also mount chained-URLs and use special settings:
+
+    python3 -m fsspec.fuse 'filecache::zip::file://data.zip' \\
+            / /tmp/zip \\
+            -o 'filecache-cache_storage=/tmp/simplecache'
+
+    You can specify the type of the setting by using `[int]` or `[bool]`,
+    (`true`, `yes`, `1` represents the Boolean value `True`):
+
+    python3 -m fsspec.fuse 'simplecache::ftp://ftp1.at.proftpd.org' \\
+            /historic/packages/RPMS /tmp/ftp \\
+            -o 'simplecache-cache_storage=/tmp/simplecache' \\
+            -o 'simplecache-check_files=false[bool]' \\
+            -o 'ftp-listings_expiry_time=60[int]' \\
+            -o 'ftp-username=anonymous' \\
+            -o 'ftp-password=xieyanbo'
+    """
+
+    class RawDescriptionArgumentParser(argparse.ArgumentParser):
+        def format_help(self):
+            usage = super().format_help()
+            parts = usage.split("\n\n")
+            parts[1] = self.description.rstrip()
+            return "\n\n".join(parts)
+
+    parser = RawDescriptionArgumentParser(prog="fsspec.fuse", description=main.__doc__)
+    parser.add_argument("--version", action="version", version=__version__)
+    parser.add_argument("url", type=str, help="fs url")
+    parser.add_argument("source_path", type=str, help="source directory in fs")
+    parser.add_argument("mount_point", type=str, help="local directory")
+    parser.add_argument(
+        "-o",
+        "--option",
+        action="append",
+        help="Any options of protocol included in the chained URL",
+    )
+    parser.add_argument(
+        "-l", "--log-file", type=str, help="Logging FUSE debug info (Default: '')"
+    )
+    parser.add_argument(
+        "-f",
+        "--foreground",
+        action="store_false",
+        help="Running in foreground or not (Default: False)",
+    )
+    parser.add_argument(
+        "-t",
+        "--threads",
+        action="store_false",
+        help="Running with threads support (Default: False)",
+    )
+    parser.add_argument(
+        "-r",
+        "--ready-file",
+        action="store_false",
+        help="The `.fuse_ready` file will exist after FUSE is ready. "
+        "(Debugging purpose, Default: False)",
+    )
+    args = parser.parse_args(args)
+
+    kwargs = {}
+    for item in args.option or []:
+        key, sep, value = item.partition("=")
+        if not sep:
+            parser.error(message=f"Wrong option: {item!r}")
+        val = value.lower()
+        if val.endswith("[int]"):
+            value = int(value[: -len("[int]")])
+        elif val.endswith("[bool]"):
+            value = val[: -len("[bool]")] in ["1", "yes", "true"]
+
+        if "-" in key:
+            fs_name, setting_name = key.split("-", 1)
+            if fs_name in kwargs:
+                kwargs[fs_name][setting_name] = value
+            else:
+                kwargs[fs_name] = {setting_name: value}
+        else:
+            kwargs[key] = value
+
+    if args.log_file:
+        logging.basicConfig(
+            level=logging.DEBUG,
+            filename=args.log_file,
+            format="%(asctime)s %(message)s",
+        )
+
+        class LoggingFUSEr(FUSEr, LoggingMixIn):
+            pass
+
+        fuser = LoggingFUSEr
+    else:
+        fuser = FUSEr
+
+    fs, url_path = url_to_fs(args.url, **kwargs)
+    logger.debug("Mounting %s to %s", url_path, str(args.mount_point))
+    run(
+        fs,
+        args.source_path,
+        args.mount_point,
+        foreground=args.foreground,
+        threads=args.threads,
+        ready_file=args.ready_file,
+        ops_class=fuser,
+    )
+
+
+if __name__ == "__main__":
+    import sys
+
+    main(sys.argv[1:])
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/generic.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/generic.py
new file mode 100644
index 0000000000000000000000000000000000000000..0600e942d08e8974203795e28d43cfa0928a60ea
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/generic.py
@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import shutil
+import uuid
+
+from .asyn import AsyncFileSystem, _run_coros_in_chunks, sync_wrapper
+from .callbacks import DEFAULT_CALLBACK
+from .core import filesystem, get_filesystem_class, split_protocol, url_to_fs
+
+_generic_fs = {}
+logger = logging.getLogger("fsspec.generic")
+
+
+def set_generic_fs(protocol, **storage_options):
+    """Populate the dict used for method=="generic" lookups"""
+    _generic_fs[protocol] = filesystem(protocol, **storage_options)
+
+
+def _resolve_fs(url, method, protocol=None, storage_options=None):
+    """Pick instance of backend FS"""
+    url = url[0] if isinstance(url, (list, tuple)) else url
+    protocol = protocol or split_protocol(url)[0]
+    storage_options = storage_options or {}
+    if method == "default":
+        return filesystem(protocol)
+    if method == "generic":
+        return _generic_fs[protocol]
+    if method == "current":
+        cls = get_filesystem_class(protocol)
+        return cls.current()
+    if method == "options":
+        fs, _ = url_to_fs(url, **storage_options.get(protocol, {}))
+        return fs
+    raise ValueError(f"Unknown FS resolution method: {method}")
+
+
+def rsync(
+    source,
+    destination,
+    delete_missing=False,
+    source_field="size",
+    dest_field="size",
+    update_cond="different",
+    inst_kwargs=None,
+    fs=None,
+    **kwargs,
+):
+    """Sync files between two directory trees
+
+    (experimental)
+
+    Parameters
+    ----------
+    source: str
+        Root of the directory tree to take files from. This must be a directory, but
+        do not include any terminating "/" character
+    destination: str
+        Root path to copy into. The contents of this location should be
+        identical to the contents of ``source`` when done. This will be made a
+        directory, and the terminal "/" should not be included.
+    delete_missing: bool
+        If there are paths in the destination that don't exist in the
+        source and this is True, delete them. Otherwise, leave them alone.
+    source_field: str | callable
+        If ``update_field`` is "different", this is the key in the info
+        of source files to consider for difference. Maybe a function of the
+        info dict.
+    dest_field: str | callable
+        If ``update_field`` is "different", this is the key in the info
+        of destination files to consider for difference. May be a function of
+        the info dict.
+    update_cond: "different"|"always"|"never"
+        If "always", every file is copied, regardless of whether it exists in
+        the destination. If "never", files that exist in the destination are
+        not copied again. If "different" (default), only copy if the info
+        fields given by ``source_field`` and ``dest_field`` (usually "size")
+        are different. Other comparisons may be added in the future.
+    inst_kwargs: dict|None
+        If ``fs`` is None, use this set of keyword arguments to make a
+        GenericFileSystem instance
+    fs: GenericFileSystem|None
+        Instance to use if explicitly given. The instance defines how to
+        to make downstream file system instances from paths.
+
+    Returns
+    -------
+    dict of the copy operations that were performed, {source: destination}
+    """
+    fs = fs or GenericFileSystem(**(inst_kwargs or {}))
+    source = fs._strip_protocol(source)
+    destination = fs._strip_protocol(destination)
+    allfiles = fs.find(source, withdirs=True, detail=True)
+    if not fs.isdir(source):
+        raise ValueError("Can only rsync on a directory")
+    otherfiles = fs.find(destination, withdirs=True, detail=True)
+    dirs = [
+        a
+        for a, v in allfiles.items()
+        if v["type"] == "directory" and a.replace(source, destination) not in otherfiles
+    ]
+    logger.debug(f"{len(dirs)} directories to create")
+    if dirs:
+        fs.make_many_dirs(
+            [dirn.replace(source, destination) for dirn in dirs], exist_ok=True
+        )
+    allfiles = {a: v for a, v in allfiles.items() if v["type"] == "file"}
+    logger.debug(f"{len(allfiles)} files to consider for copy")
+    to_delete = [
+        o
+        for o, v in otherfiles.items()
+        if o.replace(destination, source) not in allfiles and v["type"] == "file"
+    ]
+    for k, v in allfiles.copy().items():
+        otherfile = k.replace(source, destination)
+        if otherfile in otherfiles:
+            if update_cond == "always":
+                allfiles[k] = otherfile
+            elif update_cond == "never":
+                allfiles.pop(k)
+            elif update_cond == "different":
+                inf1 = source_field(v) if callable(source_field) else v[source_field]
+                v2 = otherfiles[otherfile]
+                inf2 = dest_field(v2) if callable(dest_field) else v2[dest_field]
+                if inf1 != inf2:
+                    # details mismatch, make copy
+                    allfiles[k] = otherfile
+                else:
+                    # details match, don't copy
+                    allfiles.pop(k)
+        else:
+            # file not in target yet
+            allfiles[k] = otherfile
+    logger.debug(f"{len(allfiles)} files to copy")
+    if allfiles:
+        source_files, target_files = zip(*allfiles.items())
+        fs.cp(source_files, target_files, **kwargs)
+    logger.debug(f"{len(to_delete)} files to delete")
+    if delete_missing and to_delete:
+        fs.rm(to_delete)
+    return allfiles
+
+
+class GenericFileSystem(AsyncFileSystem):
+    """Wrapper over all other FS types
+
+    <experimental!>
+
+    This implementation is a single unified interface to be able to run FS operations
+    over generic URLs, and dispatch to the specific implementations using the URL
+    protocol prefix.
+
+    Note: instances of this FS are always async, even if you never use it with any async
+    backend.
+    """
+
+    protocol = "generic"  # there is no real reason to ever use a protocol with this FS
+
+    def __init__(self, default_method="default", storage_options=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        default_method: str (optional)
+            Defines how to configure backend FS instances. Options are:
+            - "default": instantiate like FSClass(), with no
+              extra arguments; this is the default instance of that FS, and can be
+              configured via the config system
+            - "generic": takes instances from the `_generic_fs` dict in this module,
+              which you must populate before use. Keys are by protocol
+            - "options": expects storage_options, a dict mapping protocol to
+              kwargs to use when constructing the filesystem
+            - "current": takes the most recently instantiated version of each FS
+        """
+        self.method = default_method
+        self.st_opts = storage_options
+        super().__init__(**kwargs)
+
+    def _parent(self, path):
+        fs = _resolve_fs(path, self.method, storage_options=self.st_opts)
+        return fs.unstrip_protocol(fs._parent(path))
+
+    def _strip_protocol(self, path):
+        # normalization only
+        fs = _resolve_fs(path, self.method, storage_options=self.st_opts)
+        return fs.unstrip_protocol(fs._strip_protocol(path))
+
+    async def _find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        fs = _resolve_fs(path, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            out = await fs._find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+            )
+        else:
+            out = fs.find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=True, **kwargs
+            )
+        result = {}
+        for k, v in out.items():
+            v = v.copy()  # don't corrupt target FS dircache
+            name = fs.unstrip_protocol(k)
+            v["name"] = name
+            result[name] = v
+        if detail:
+            return result
+        return list(result)
+
+    async def _info(self, url, **kwargs):
+        fs = _resolve_fs(url, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            out = await fs._info(url, **kwargs)
+        else:
+            out = fs.info(url, **kwargs)
+        out = out.copy()  # don't edit originals
+        out["name"] = fs.unstrip_protocol(out["name"])
+        return out
+
+    async def _ls(
+        self,
+        url,
+        detail=True,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            out = await fs._ls(url, detail=True, **kwargs)
+        else:
+            out = fs.ls(url, detail=True, **kwargs)
+        out = [o.copy() for o in out]  # don't edit originals
+        for o in out:
+            o["name"] = fs.unstrip_protocol(o["name"])
+        if detail:
+            return out
+        else:
+            return [o["name"] for o in out]
+
+    async def _cat_file(
+        self,
+        url,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            return await fs._cat_file(url, **kwargs)
+        else:
+            return fs.cat_file(url, **kwargs)
+
+    async def _pipe_file(
+        self,
+        path,
+        value,
+        **kwargs,
+    ):
+        fs = _resolve_fs(path, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            return await fs._pipe_file(path, value, **kwargs)
+        else:
+            return fs.pipe_file(path, value, **kwargs)
+
+    async def _rm(self, url, **kwargs):
+        urls = url
+        if isinstance(urls, str):
+            urls = [urls]
+        fs = _resolve_fs(urls[0], self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            await fs._rm(urls, **kwargs)
+        else:
+            fs.rm(url, **kwargs)
+
+    async def _makedirs(self, path, exist_ok=False):
+        logger.debug("Make dir %s", path)
+        fs = _resolve_fs(path, self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            await fs._makedirs(path, exist_ok=exist_ok)
+        else:
+            fs.makedirs(path, exist_ok=exist_ok)
+
+    def rsync(self, source, destination, **kwargs):
+        """Sync files between two directory trees
+
+        See `func:rsync` for more details.
+        """
+        rsync(source, destination, fs=self, **kwargs)
+
+    async def _cp_file(
+        self,
+        url,
+        url2,
+        blocksize=2**20,
+        callback=DEFAULT_CALLBACK,
+        tempdir: str | None = None,
+        **kwargs,
+    ):
+        fs = _resolve_fs(url, self.method, storage_options=self.st_opts)
+        fs2 = _resolve_fs(url2, self.method, storage_options=self.st_opts)
+        if fs is fs2:
+            # pure remote
+            if fs.async_impl:
+                return await fs._copy(url, url2, **kwargs)
+            else:
+                return fs.copy(url, url2, **kwargs)
+        await copy_file_op(fs, [url], fs2, [url2], tempdir, 1, on_error="raise")
+
+    async def _make_many_dirs(self, urls, exist_ok=True):
+        fs = _resolve_fs(urls[0], self.method, storage_options=self.st_opts)
+        if fs.async_impl:
+            coros = [fs._makedirs(u, exist_ok=exist_ok) for u in urls]
+            await _run_coros_in_chunks(coros)
+        else:
+            for u in urls:
+                fs.makedirs(u, exist_ok=exist_ok)
+
+    make_many_dirs = sync_wrapper(_make_many_dirs)
+
+    async def _copy(
+        self,
+        path1: list[str],
+        path2: list[str],
+        recursive: bool = False,
+        on_error: str = "ignore",
+        maxdepth: int | None = None,
+        batch_size: int | None = None,
+        tempdir: str | None = None,
+        **kwargs,
+    ):
+        # TODO: special case for one FS being local, which can use get/put
+        # TODO: special case for one being memFS, which can use cat/pipe
+        if recursive:
+            raise NotImplementedError("Please use fsspec.generic.rsync")
+        path1 = [path1] if isinstance(path1, str) else path1
+        path2 = [path2] if isinstance(path2, str) else path2
+
+        fs = _resolve_fs(path1, self.method, storage_options=self.st_opts)
+        fs2 = _resolve_fs(path2, self.method, storage_options=self.st_opts)
+
+        if fs is fs2:
+            if fs.async_impl:
+                return await fs._copy(path1, path2, **kwargs)
+            else:
+                return fs.copy(path1, path2, **kwargs)
+
+        await copy_file_op(
+            fs, path1, fs2, path2, tempdir, batch_size, on_error=on_error
+        )
+
+
+async def copy_file_op(
+    fs1, url1, fs2, url2, tempdir=None, batch_size=20, on_error="ignore"
+):
+    import tempfile
+
+    tempdir = tempdir or tempfile.mkdtemp()
+    try:
+        coros = [
+            _copy_file_op(
+                fs1,
+                u1,
+                fs2,
+                u2,
+                os.path.join(tempdir, uuid.uuid4().hex),
+            )
+            for u1, u2 in zip(url1, url2)
+        ]
+        out = await _run_coros_in_chunks(
+            coros, batch_size=batch_size, return_exceptions=True
+        )
+    finally:
+        shutil.rmtree(tempdir)
+    if on_error == "return":
+        return out
+    elif on_error == "raise":
+        for o in out:
+            if isinstance(o, Exception):
+                raise o
+
+
+async def _copy_file_op(fs1, url1, fs2, url2, local, on_error="ignore"):
+    if fs1.async_impl:
+        await fs1._get_file(url1, local)
+    else:
+        fs1.get_file(url1, local)
+    if fs2.async_impl:
+        await fs2._put_file(local, url2)
+    else:
+        fs2.put_file(local, url2)
+    os.unlink(local)
+    logger.debug("Copy %s -> %s; done", url1, url2)
+
+
+async def maybe_await(cor):
+    if inspect.iscoroutine(cor):
+        return await cor
+    else:
+        return cor
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/gui.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/gui.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d914c8beb6cabb2c2700eb8eee31028559be2bd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/gui.py
@@ -0,0 +1,417 @@
+import ast
+import contextlib
+import logging
+import os
+import re
+from collections.abc import Sequence
+from typing import ClassVar
+
+import panel as pn
+
+from .core import OpenFile, get_filesystem_class, split_protocol
+from .registry import known_implementations
+
+pn.extension()
+logger = logging.getLogger("fsspec.gui")
+
+
+class SigSlot:
+    """Signal-slot mixin, for Panel event passing
+
+    Include this class in a widget manager's superclasses to be able to
+    register events and callbacks on Panel widgets managed by that class.
+
+    The method ``_register`` should be called as widgets are added, and external
+    code should call ``connect`` to associate callbacks.
+
+    By default, all signals emit a DEBUG logging statement.
+    """
+
+    # names of signals that this class may emit each of which must be
+    # set by _register for any new instance
+    signals: ClassVar[Sequence[str]] = []
+    # names of actions that this class may respond to
+    slots: ClassVar[Sequence[str]] = []
+
+    # each of which must be a method name
+
+    def __init__(self):
+        self._ignoring_events = False
+        self._sigs = {}
+        self._map = {}
+        self._setup()
+
+    def _setup(self):
+        """Create GUI elements and register signals"""
+        self.panel = pn.pane.PaneBase()
+        # no signals to set up in the base class
+
+    def _register(
+        self, widget, name, thing="value", log_level=logging.DEBUG, auto=False
+    ):
+        """Watch the given attribute of a widget and assign it a named event
+
+        This is normally called at the time a widget is instantiated, in the
+        class which owns it.
+
+        Parameters
+        ----------
+        widget : pn.layout.Panel or None
+            Widget to watch. If None, an anonymous signal not associated with
+            any widget.
+        name : str
+            Name of this event
+        thing : str
+            Attribute of the given widget to watch
+        log_level : int
+            When the signal is triggered, a logging event of the given level
+            will be fired in the dfviz logger.
+        auto : bool
+            If True, automatically connects with a method in this class of the
+            same name.
+        """
+        if name not in self.signals:
+            raise ValueError(f"Attempt to assign an undeclared signal: {name}")
+        self._sigs[name] = {
+            "widget": widget,
+            "callbacks": [],
+            "thing": thing,
+            "log": log_level,
+        }
+        wn = "-".join(
+            [
+                getattr(widget, "name", str(widget)) if widget is not None else "none",
+                thing,
+            ]
+        )
+        self._map[wn] = name
+        if widget is not None:
+            widget.param.watch(self._signal, thing, onlychanged=True)
+        if auto and hasattr(self, name):
+            self.connect(name, getattr(self, name))
+
+    def _repr_mimebundle_(self, *args, **kwargs):
+        """Display in a notebook or a server"""
+        try:
+            return self.panel._repr_mimebundle_(*args, **kwargs)
+        except (ValueError, AttributeError) as exc:
+            raise NotImplementedError(
+                "Panel does not seem to be set up properly"
+            ) from exc
+
+    def connect(self, signal, slot):
+        """Associate call back with given event
+
+        The callback must be a function which takes the "new" value of the
+        watched attribute as the only parameter. If the callback return False,
+        this cancels any further processing of the given event.
+
+        Alternatively, the callback can be a string, in which case it means
+        emitting the correspondingly-named event (i.e., connect to self)
+        """
+        self._sigs[signal]["callbacks"].append(slot)
+
+    def _signal(self, event):
+        """This is called by a an action on a widget
+
+        Within an self.ignore_events context, nothing happens.
+
+        Tests can execute this method by directly changing the values of
+        widget components.
+        """
+        if not self._ignoring_events:
+            wn = "-".join([event.obj.name, event.name])
+            if wn in self._map and self._map[wn] in self._sigs:
+                self._emit(self._map[wn], event.new)
+
+    @contextlib.contextmanager
+    def ignore_events(self):
+        """Temporarily turn off events processing in this instance
+
+        (does not propagate to children)
+        """
+        self._ignoring_events = True
+        try:
+            yield
+        finally:
+            self._ignoring_events = False
+
+    def _emit(self, sig, value=None):
+        """An event happened, call its callbacks
+
+        This method can be used in tests to simulate message passing without
+        directly changing visual elements.
+
+        Calling of callbacks will halt whenever one returns False.
+        """
+        logger.log(self._sigs[sig]["log"], f"{sig}: {value}")
+        for callback in self._sigs[sig]["callbacks"]:
+            if isinstance(callback, str):
+                self._emit(callback)
+            else:
+                try:
+                    # running callbacks should not break the interface
+                    ret = callback(value)
+                    if ret is False:
+                        break
+                except Exception as e:
+                    logger.exception(
+                        "Exception (%s) while executing callback for signal: %s",
+                        e,
+                        sig,
+                    )
+
+    def show(self, threads=False):
+        """Open a new browser tab and display this instance's interface"""
+        self.panel.show(threads=threads, verbose=False)
+        return self
+
+
+class SingleSelect(SigSlot):
+    """A multiselect which only allows you to select one item for an event"""
+
+    signals = ["_selected", "selected"]  # the first is internal
+    slots = ["set_options", "set_selection", "add", "clear", "select"]
+
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+        super().__init__()
+
+    def _setup(self):
+        self.panel = pn.widgets.MultiSelect(**self.kwargs)
+        self._register(self.panel, "_selected", "value")
+        self._register(None, "selected")
+        self.connect("_selected", self.select_one)
+
+    def _signal(self, *args, **kwargs):
+        super()._signal(*args, **kwargs)
+
+    def select_one(self, *_):
+        with self.ignore_events():
+            val = [self.panel.value[-1]] if self.panel.value else []
+            self.panel.value = val
+        self._emit("selected", self.panel.value)
+
+    def set_options(self, options):
+        self.panel.options = options
+
+    def clear(self):
+        self.panel.options = []
+
+    @property
+    def value(self):
+        return self.panel.value
+
+    def set_selection(self, selection):
+        self.panel.value = [selection]
+
+
+class FileSelector(SigSlot):
+    """Panel-based graphical file selector widget
+
+    Instances of this widget are interactive and can be displayed in jupyter by having
+    them as the output of a cell,  or in a separate browser tab using ``.show()``.
+    """
+
+    signals = [
+        "protocol_changed",
+        "selection_changed",
+        "directory_entered",
+        "home_clicked",
+        "up_clicked",
+        "go_clicked",
+        "filters_changed",
+    ]
+    slots = ["set_filters", "go_home"]
+
+    def __init__(self, url=None, filters=None, ignore=None, kwargs=None):
+        """
+
+        Parameters
+        ----------
+        url : str (optional)
+            Initial value of the URL to populate the dialog; should include protocol
+        filters : list(str) (optional)
+            File endings to include in the listings. If not included, all files are
+            allowed. Does not affect directories.
+            If given, the endings will appear as checkboxes in the interface
+        ignore : list(str) (optional)
+            Regex(s) of file basename patterns to ignore, e.g., "\\." for typical
+            hidden files on posix
+        kwargs : dict (optional)
+            To pass to file system instance
+        """
+        if url:
+            self.init_protocol, url = split_protocol(url)
+        else:
+            self.init_protocol, url = "file", os.getcwd()
+        self.init_url = url
+        self.init_kwargs = (kwargs if isinstance(kwargs, str) else str(kwargs)) or "{}"
+        self.filters = filters
+        self.ignore = [re.compile(i) for i in ignore or []]
+        self._fs = None
+        super().__init__()
+
+    def _setup(self):
+        self.url = pn.widgets.TextInput(
+            name="url",
+            value=self.init_url,
+            align="end",
+            sizing_mode="stretch_width",
+            width_policy="max",
+        )
+        self.protocol = pn.widgets.Select(
+            options=sorted(known_implementations),
+            value=self.init_protocol,
+            name="protocol",
+            align="center",
+        )
+        self.kwargs = pn.widgets.TextInput(
+            name="kwargs", value=self.init_kwargs, align="center"
+        )
+        self.go = pn.widgets.Button(name="⇨", align="end", width=45)
+        self.main = SingleSelect(size=10)
+        self.home = pn.widgets.Button(name="🏠", width=40, height=30, align="end")
+        self.up = pn.widgets.Button(name="‹", width=30, height=30, align="end")
+
+        self._register(self.protocol, "protocol_changed", auto=True)
+        self._register(self.go, "go_clicked", "clicks", auto=True)
+        self._register(self.up, "up_clicked", "clicks", auto=True)
+        self._register(self.home, "home_clicked", "clicks", auto=True)
+        self._register(None, "selection_changed")
+        self.main.connect("selected", self.selection_changed)
+        self._register(None, "directory_entered")
+        self.prev_protocol = self.protocol.value
+        self.prev_kwargs = self.storage_options
+
+        self.filter_sel = pn.widgets.CheckBoxGroup(
+            value=[], options=[], inline=False, align="end", width_policy="min"
+        )
+        self._register(self.filter_sel, "filters_changed", auto=True)
+
+        self.panel = pn.Column(
+            pn.Row(self.protocol, self.kwargs),
+            pn.Row(self.home, self.up, self.url, self.go, self.filter_sel),
+            self.main.panel,
+        )
+        self.set_filters(self.filters)
+        self.go_clicked()
+
+    def set_filters(self, filters=None):
+        self.filters = filters
+        if filters:
+            self.filter_sel.options = filters
+            self.filter_sel.value = filters
+        else:
+            self.filter_sel.options = []
+            self.filter_sel.value = []
+
+    @property
+    def storage_options(self):
+        """Value of the kwargs box as a dictionary"""
+        return ast.literal_eval(self.kwargs.value) or {}
+
+    @property
+    def fs(self):
+        """Current filesystem instance"""
+        if self._fs is None:
+            cls = get_filesystem_class(self.protocol.value)
+            self._fs = cls(**self.storage_options)
+        return self._fs
+
+    @property
+    def urlpath(self):
+        """URL of currently selected item"""
+        return (
+            (f"{self.protocol.value}://{self.main.value[0]}")
+            if self.main.value
+            else None
+        )
+
+    def open_file(self, mode="rb", compression=None, encoding=None):
+        """Create OpenFile instance for the currently selected item
+
+        For example, in a notebook you might do something like
+
+        .. code-block::
+
+            [ ]: sel = FileSelector(); sel
+
+            # user selects their file
+
+            [ ]: with sel.open_file('rb') as f:
+            ...      out = f.read()
+
+        Parameters
+        ----------
+        mode: str (optional)
+            Open mode for the file.
+        compression: str (optional)
+            The interact with the file as compressed. Set to 'infer' to guess
+            compression from the file ending
+        encoding: str (optional)
+            If using text mode, use this encoding; defaults to UTF8.
+        """
+        if self.urlpath is None:
+            raise ValueError("No file selected")
+        return OpenFile(self.fs, self.urlpath, mode, compression, encoding)
+
+    def filters_changed(self, values):
+        self.filters = values
+        self.go_clicked()
+
+    def selection_changed(self, *_):
+        if self.urlpath is None:
+            return
+        if self.fs.isdir(self.urlpath):
+            self.url.value = self.fs._strip_protocol(self.urlpath)
+        self.go_clicked()
+
+    def go_clicked(self, *_):
+        if (
+            self.prev_protocol != self.protocol.value
+            or self.prev_kwargs != self.storage_options
+        ):
+            self._fs = None  # causes fs to be recreated
+            self.prev_protocol = self.protocol.value
+            self.prev_kwargs = self.storage_options
+        listing = sorted(
+            self.fs.ls(self.url.value, detail=True), key=lambda x: x["name"]
+        )
+        listing = [
+            l
+            for l in listing
+            if not any(i.match(l["name"].rsplit("/", 1)[-1]) for i in self.ignore)
+        ]
+        folders = {
+            "📁 " + o["name"].rsplit("/", 1)[-1]: o["name"]
+            for o in listing
+            if o["type"] == "directory"
+        }
+        files = {
+            "📄 " + o["name"].rsplit("/", 1)[-1]: o["name"]
+            for o in listing
+            if o["type"] == "file"
+        }
+        if self.filters:
+            files = {
+                k: v
+                for k, v in files.items()
+                if any(v.endswith(ext) for ext in self.filters)
+            }
+        self.main.set_options(dict(**folders, **files))
+
+    def protocol_changed(self, *_):
+        self._fs = None
+        self.main.options = []
+        self.url.value = ""
+
+    def home_clicked(self, *_):
+        self.protocol.value = self.init_protocol
+        self.kwargs.value = self.init_kwargs
+        self.url.value = self.init_url
+        self.go_clicked()
+
+    def up_clicked(self, *_):
+        self.url.value = self.fs._parent(self.url.value)
+        self.go_clicked()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a455414d1eb0fa61e4b5406c82f5ef58dbf77ed4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dd54db9afb12c7b346c297fc316c9c522f2a9ec6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/arrow.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/asyn_wrapper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/asyn_wrapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..075b9da1d6b8dd6218508a70fa7a2eac21dd4d8f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/asyn_wrapper.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..92e0ffc9d29a1a3d8c10b4c83a5055ff9f5af14f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_mapper.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfc2c09d492a5df2d9c4d5e3cbccd8d74fdd2011
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cache_metadata.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2f640de8747c98dd42881db2b804fa8440358886
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/cached.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/chained.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/chained.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6861c036925ba3d9c3430503179f083c57cb8495
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/chained.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08801ef1379c1c89228692596defd257ba230d44
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dask.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..26bf57c9818dbbc0be4d553928fa4312dd89071c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/data.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9d6d057df810662b377206231ed093110c6b966
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dbfs.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..401c971087e607b738cc6a980df9da7b7b4cfea6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/dirfs.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e468a1bf839b896a54138d13d06b0075996b37b1
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/ftp.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/gist.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/gist.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9ab0e7177a7477257eb07a67196b901549119c31
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/gist.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4f95fdb97d765a7225e82b30cb559f949605e0a2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/git.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4755f70bb41e7677abe15185b6024496b4bb8e28
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/github.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3781602175000faa8f9154d5e5c48611803311a2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http_sync.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http_sync.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7876cca7401ec1b7990a237411be9b3e7a7767f0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/http_sync.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44b1a1a1ede043d23382a4348e83980f2c909f82
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/jupyter.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e33a0f40434974f1927838a2760da40befe7db70
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/libarchive.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..922645e617d5139171911b528cef4a5870ca6994
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/local.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3d25a433226c75338caebb54554cb641bb8aac8d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/memory.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f57742a8d38f68790ee1d7af18bdb84e455aaf33
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/reference.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6cc24be3edfb34359b4b53703cabbf59d4ff8e8e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/sftp.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7ca4877e6b5e81c636c2530897b0bf93e1356b68
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/smb.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d4807372174a75703f6c0a0ce2fe56292cb935ea
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/tar.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4f9830554ba183879a2acef41a88bf5db0df046
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/webhdfs.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..245f4695b99b41ea2623a73e1c14324868f45b20
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/__pycache__/zip.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/arrow.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/arrow.py
new file mode 100644
index 0000000000000000000000000000000000000000..28d39b84b980a21cbd296023c7fd11f859418540
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/arrow.py
@@ -0,0 +1,328 @@
+import errno
+import io
+import os
+import secrets
+import shutil
+from contextlib import suppress
+from functools import cached_property, wraps
+from urllib.parse import parse_qs
+
+from fsspec.spec import AbstractFileSystem
+from fsspec.utils import (
+    get_package_version_without_import,
+    infer_storage_options,
+    mirror_from,
+    tokenize,
+)
+
+
+def wrap_exceptions(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except OSError as exception:
+            if not exception.args:
+                raise
+
+            message, *args = exception.args
+            if isinstance(message, str) and "does not exist" in message:
+                raise FileNotFoundError(errno.ENOENT, message) from exception
+            else:
+                raise
+
+    return wrapper
+
+
+PYARROW_VERSION = None
+_EMPTY_ROOT_MARKER_FILESYSTEMS = {"gcs", "s3"}
+
+
+class ArrowFSWrapper(AbstractFileSystem):
+    """FSSpec-compatible wrapper of pyarrow.fs.FileSystem.
+
+    Parameters
+    ----------
+    fs : pyarrow.fs.FileSystem
+
+    """
+
+    root_marker = "/"
+
+    def __init__(self, fs, **kwargs):
+        global PYARROW_VERSION
+        PYARROW_VERSION = get_package_version_without_import("pyarrow")
+        self.fs = fs
+        if fs.type_name in _EMPTY_ROOT_MARKER_FILESYSTEMS:
+            self.root_marker = ""
+        super().__init__(**kwargs)
+
+    @property
+    def protocol(self):
+        return self.fs.type_name
+
+    @cached_property
+    def fsid(self):
+        return "hdfs_" + tokenize(self.fs.host, self.fs.port)
+
+    def _parent(self, path):
+        if self.root_marker:
+            return super()._parent(path)
+
+        path = self._strip_protocol(path).lstrip("/")
+        return path.rsplit("/", 1)[0] if "/" in path else ""
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        ops = infer_storage_options(path)
+        path = ops["path"]
+        if path.startswith("//"):
+            # special case for "hdfs://path" (without the triple slash)
+            path = path[1:]
+        return path
+
+    def ls(self, path, detail=False, **kwargs):
+        path = self._strip_protocol(path)
+        from pyarrow.fs import FileSelector
+
+        try:
+            entries = [
+                self._make_entry(entry)
+                for entry in self.fs.get_file_info(FileSelector(path))
+            ]
+        except (FileNotFoundError, NotADirectoryError):
+            entries = [self.info(path, **kwargs)]
+        if detail:
+            return entries
+        else:
+            return [entry["name"] for entry in entries]
+
+    def info(self, path, **kwargs):
+        path = self._strip_protocol(path)
+        [info] = self.fs.get_file_info([path])
+        return self._make_entry(info)
+
+    def exists(self, path):
+        path = self._strip_protocol(path)
+        try:
+            self.info(path)
+        except FileNotFoundError:
+            return False
+        else:
+            return True
+
+    def _make_entry(self, info):
+        from pyarrow.fs import FileType
+
+        if info.type is FileType.Directory:
+            kind = "directory"
+        elif info.type is FileType.File:
+            kind = "file"
+        elif info.type is FileType.NotFound:
+            raise FileNotFoundError(errno.ENOENT, os.strerror(errno.ENOENT), info.path)
+        else:
+            kind = "other"
+
+        return {
+            "name": info.path,
+            "size": info.size,
+            "type": kind,
+            "mtime": info.mtime,
+        }
+
+    @wrap_exceptions
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+
+        with self._open(path1, "rb") as lstream:
+            tmp_fname = f"{path2}.tmp.{secrets.token_hex(6)}"
+            try:
+                with self.open(tmp_fname, "wb") as rstream:
+                    shutil.copyfileobj(lstream, rstream)
+                self.fs.move(tmp_fname, path2)
+            except BaseException:
+                with suppress(FileNotFoundError):
+                    self.fs.delete_file(tmp_fname)
+                raise
+
+    @wrap_exceptions
+    def mv(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1).rstrip("/")
+        path2 = self._strip_protocol(path2).rstrip("/")
+        self.fs.move(path1, path2)
+
+    @wrap_exceptions
+    def rm_file(self, path):
+        path = self._strip_protocol(path)
+        self.fs.delete_file(path)
+
+    @wrap_exceptions
+    def rm(self, path, recursive=False, maxdepth=None):
+        path = self._strip_protocol(path).rstrip("/")
+        if self.isdir(path):
+            if recursive:
+                self.fs.delete_dir(path)
+            else:
+                raise ValueError("Can't delete directories without recursive=False")
+        else:
+            self.fs.delete_file(path)
+
+    @wrap_exceptions
+    def _open(self, path, mode="rb", block_size=None, seekable=True, **kwargs):
+        if mode == "rb":
+            if seekable:
+                method = self.fs.open_input_file
+            else:
+                method = self.fs.open_input_stream
+        elif mode == "wb":
+            method = self.fs.open_output_stream
+        elif mode == "ab":
+            method = self.fs.open_append_stream
+        else:
+            raise ValueError(f"unsupported mode for Arrow filesystem: {mode!r}")
+
+        _kwargs = {}
+        if mode != "rb" or not seekable:
+            if int(PYARROW_VERSION.split(".")[0]) >= 4:
+                # disable compression auto-detection
+                _kwargs["compression"] = None
+        stream = method(path, **_kwargs)
+
+        return ArrowFile(self, stream, path, mode, block_size, **kwargs)
+
+    @wrap_exceptions
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if create_parents:
+            self.makedirs(path, exist_ok=True)
+        else:
+            self.fs.create_dir(path, recursive=False)
+
+    @wrap_exceptions
+    def makedirs(self, path, exist_ok=False):
+        path = self._strip_protocol(path)
+        self.fs.create_dir(path, recursive=True)
+
+    @wrap_exceptions
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        self.fs.delete_dir(path)
+
+    @wrap_exceptions
+    def modified(self, path):
+        path = self._strip_protocol(path)
+        return self.fs.get_file_info(path).mtime
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        kwargs.setdefault("seekable", start not in [None, 0])
+        return super().cat_file(path, start, end, **kwargs)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        kwargs.setdefault("seekable", False)
+        super().get_file(rpath, lpath, **kwargs)
+
+
+@mirror_from(
+    "stream",
+    [
+        "read",
+        "readinto",
+        "seek",
+        "tell",
+        "write",
+        "flush",
+        "readable",
+        "writable",
+        "close",
+        "seekable",
+    ],
+)
+class ArrowFile(io.IOBase):
+    def __init__(self, fs, stream, path, mode, block_size=None, **kwargs):
+        self.path = path
+        self.mode = mode
+
+        self.fs = fs
+        self.stream = stream
+
+        self.blocksize = self.block_size = block_size
+        self.kwargs = kwargs
+
+    def __enter__(self):
+        return self
+
+    @property
+    def closed(self):
+        return self.stream.closed
+
+    @property
+    def size(self):
+        if self.stream.seekable():
+            return self.stream.size()
+        return None
+
+    def __exit__(self, *args):
+        return self.close()
+
+
+class HadoopFileSystem(ArrowFSWrapper):
+    """A wrapper on top of the pyarrow.fs.HadoopFileSystem
+    to connect it's interface with fsspec"""
+
+    protocol = "hdfs"
+
+    def __init__(
+        self,
+        host="default",
+        port=0,
+        user=None,
+        kerb_ticket=None,
+        replication=3,
+        extra_conf=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        host: str
+            Hostname, IP or "default" to try to read from Hadoop config
+        port: int
+            Port to connect on, or default from Hadoop config if 0
+        user: str or None
+            If given, connect as this username
+        kerb_ticket: str or None
+            If given, use this ticket for authentication
+        replication: int
+            set replication factor of file for write operations. default value is 3.
+        extra_conf: None or dict
+            Passed on to HadoopFileSystem
+        """
+        from pyarrow.fs import HadoopFileSystem
+
+        fs = HadoopFileSystem(
+            host=host,
+            port=port,
+            user=user,
+            kerb_ticket=kerb_ticket,
+            replication=replication,
+            extra_conf=extra_conf,
+        )
+        super().__init__(fs=fs, **kwargs)
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        ops = infer_storage_options(path)
+        out = {}
+        if ops.get("host", None):
+            out["host"] = ops["host"]
+        if ops.get("username", None):
+            out["user"] = ops["username"]
+        if ops.get("port", None):
+            out["port"] = ops["port"]
+        if ops.get("url_query", None):
+            queries = parse_qs(ops["url_query"])
+            if queries.get("replication", None):
+                out["replication"] = int(queries["replication"][0])
+        return out
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/asyn_wrapper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/asyn_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..4692e699d00d1db6a767b374a22755dffe73d6ca
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/asyn_wrapper.py
@@ -0,0 +1,135 @@
+import asyncio
+import functools
+import inspect
+
+import fsspec
+from fsspec.asyn import AsyncFileSystem, running_async
+
+from .chained import ChainedFileSystem
+
+
+def async_wrapper(func, obj=None, semaphore=None):
+    """
+    Wraps a synchronous function to make it awaitable.
+
+    Parameters
+    ----------
+    func : callable
+        The synchronous function to wrap.
+    obj : object, optional
+        The instance to bind the function to, if applicable.
+    semaphore : asyncio.Semaphore, optional
+        A semaphore to limit concurrent calls.
+
+    Returns
+    -------
+    coroutine
+        An awaitable version of the function.
+    """
+
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        if semaphore:
+            async with semaphore:
+                return await asyncio.to_thread(func, *args, **kwargs)
+        return await asyncio.to_thread(func, *args, **kwargs)
+
+    return wrapper
+
+
+class AsyncFileSystemWrapper(AsyncFileSystem, ChainedFileSystem):
+    """
+    A wrapper class to convert a synchronous filesystem into an asynchronous one.
+
+    This class takes an existing synchronous filesystem implementation and wraps all
+    its methods to provide an asynchronous interface.
+
+    Parameters
+    ----------
+    sync_fs : AbstractFileSystem
+        The synchronous filesystem instance to wrap.
+    """
+
+    protocol = "asyncwrapper", "async_wrapper"
+    cachable = False
+
+    def __init__(
+        self,
+        fs=None,
+        asynchronous=None,
+        target_protocol=None,
+        target_options=None,
+        semaphore=None,
+        max_concurrent_tasks=None,
+        **kwargs,
+    ):
+        if asynchronous is None:
+            asynchronous = running_async()
+        super().__init__(asynchronous=asynchronous, **kwargs)
+        if fs is not None:
+            self.sync_fs = fs
+        else:
+            self.sync_fs = fsspec.filesystem(target_protocol, **target_options)
+        self.protocol = self.sync_fs.protocol
+        # paths must be normalized the way the wrapped filesystem does it
+        self.root_marker = self.sync_fs.root_marker
+        self._strip_protocol = self.sync_fs._strip_protocol
+        self._parent = self.sync_fs._parent
+        self.semaphore = semaphore
+        self._wrap_all_sync_methods()
+
+    @property
+    def fsid(self):
+        return f"async_{self.sync_fs.fsid}"
+
+    def _wrap_all_sync_methods(self):
+        """
+        Wrap all synchronous methods of the underlying filesystem with asynchronous versions.
+        """
+        excluded_methods = {"open"}
+        for method_name in dir(self.sync_fs):
+            if method_name.startswith("_") or method_name in excluded_methods:
+                continue
+
+            attr = inspect.getattr_static(self.sync_fs, method_name)
+            if isinstance(attr, property):
+                continue
+
+            method = getattr(self.sync_fs, method_name)
+            # generators such as ``walk`` cannot become coroutines: the async API
+            # expects async generators, which AsyncFileSystem already builds on
+            # top of the wrapped methods (``_walk`` uses ``_ls``)
+            if (
+                callable(method)
+                and not inspect.iscoroutinefunction(method)
+                and not inspect.isgeneratorfunction(method)
+            ):
+                async_method = async_wrapper(method, obj=self, semaphore=self.semaphore)
+                setattr(self, f"_{method_name}", async_method)
+
+    @classmethod
+    def wrap_class(cls, sync_fs_class):
+        """
+        Create a new class that can be used to instantiate an AsyncFileSystemWrapper
+        with lazy instantiation of the underlying synchronous filesystem.
+
+        Parameters
+        ----------
+        sync_fs_class : type
+            The class of the synchronous filesystem to wrap.
+
+        Returns
+        -------
+        type
+            A new class that wraps the provided synchronous filesystem class.
+        """
+
+        class GeneratedAsyncFileSystemWrapper(cls):
+            def __init__(self, *args, **kwargs):
+                sync_fs = sync_fs_class(*args, **kwargs)
+                super().__init__(sync_fs)
+
+        GeneratedAsyncFileSystemWrapper.__name__ = (
+            f"Async{sync_fs_class.__name__}Wrapper"
+        )
+        return GeneratedAsyncFileSystemWrapper
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..6e7c7d88afdddf12f77b26bb635bd8bf1e2bd7f1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_mapper.py
@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import abc
+import hashlib
+
+from fsspec.implementations.local import make_path_posix
+
+
+class AbstractCacheMapper(abc.ABC):
+    """Abstract super-class for mappers from remote URLs to local cached
+    basenames.
+    """
+
+    @abc.abstractmethod
+    def __call__(self, path: str) -> str: ...
+
+    def __eq__(self, other: object) -> bool:
+        # Identity only depends on class. When derived classes have attributes
+        # they will need to be included.
+        return isinstance(other, type(self))
+
+    def __hash__(self) -> int:
+        # Identity only depends on class. When derived classes have attributes
+        # they will need to be included.
+        return hash(type(self))
+
+
+class BasenameCacheMapper(AbstractCacheMapper):
+    """Cache mapper that uses the basename of the remote URL and a fixed number
+    of directory levels above this.
+
+    The default is zero directory levels, meaning different paths with the same
+    basename will have the same cached basename.
+    """
+
+    def __init__(self, directory_levels: int = 0):
+        if directory_levels < 0:
+            raise ValueError(
+                "BasenameCacheMapper requires zero or positive directory_levels"
+            )
+        self.directory_levels = directory_levels
+
+        # Separator for directories when encoded as strings.
+        self._separator = "_@_"
+
+    def __call__(self, path: str) -> str:
+        path = make_path_posix(path)
+        prefix, *bits = path.rsplit("/", self.directory_levels + 1)
+        if bits:
+            return self._separator.join(bits)
+        else:
+            return prefix  # No separator found, simple filename
+
+    def __eq__(self, other: object) -> bool:
+        return super().__eq__(other) and self.directory_levels == other.directory_levels
+
+    def __hash__(self) -> int:
+        return super().__hash__() ^ hash(self.directory_levels)
+
+
+class HashCacheMapper(AbstractCacheMapper):
+    """Cache mapper that uses a hash of the remote URL."""
+
+    def __call__(self, path: str) -> str:
+        return hashlib.sha256(path.encode()).hexdigest()
+
+
+def create_cache_mapper(same_names: bool) -> AbstractCacheMapper:
+    """Factory method to create cache mapper for backward compatibility with
+    ``CachingFileSystem`` constructor using ``same_names`` kwarg.
+    """
+    if same_names:
+        return BasenameCacheMapper()
+    else:
+        return HashCacheMapper()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py
new file mode 100644
index 0000000000000000000000000000000000000000..2a48231cac9f984f3e41bc9f81a113ae28a1f5dd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cache_metadata.py
@@ -0,0 +1,217 @@
+from __future__ import annotations
+
+import os
+import time
+from typing import TYPE_CHECKING
+
+from fsspec.utils import atomic_write
+
+try:
+    import ujson as json
+except ImportError:
+    if not TYPE_CHECKING:
+        import json
+
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+    from typing import Any, Literal, TypeAlias
+
+    from .cached import CachingFileSystem
+
+    Detail: TypeAlias = dict[str, Any]
+
+
+class CacheMetadata:
+    """Cache metadata.
+
+    All reading and writing of cache metadata is performed by this class,
+    accessing the cached files and blocks is not.
+
+    Metadata is stored in a single file per storage directory in JSON format.
+    For backward compatibility. No longer supports pickle.
+    """
+
+    def __init__(self, storage: list[str]):
+        """
+
+        Parameters
+        ----------
+        storage: list[str]
+            Directories containing cached files, must be at least one. Metadata
+            is stored in the last of these directories by convention.
+        """
+        if not storage:
+            raise ValueError("CacheMetadata expects at least one storage location")
+
+        self._storage = storage
+        self.cached_files: list[Detail] = [{}]
+
+    def _load(self, fn: str) -> Detail:
+        """Low-level function to load metadata from specific file"""
+        with open(fn, "r") as f:
+            loaded = json.load(f)
+        for c in loaded.values():
+            if isinstance(c.get("blocks"), list):
+                c["blocks"] = set(c["blocks"])
+        return loaded
+
+    def _save(self, metadata_to_save: Detail, fn: str) -> None:
+        """Low-level function to save metadata to specific file"""
+        with atomic_write(fn, mode="w") as f:
+            json.dump(metadata_to_save, f)
+
+    def _scan_locations(
+        self, writable_only: bool = False
+    ) -> Iterator[tuple[str, str, bool]]:
+        """Yield locations (filenames) where metadata is stored, and whether
+        writable or not.
+
+        Parameters
+        ----------
+        writable: bool
+            Set to True to only yield writable locations.
+
+        Returns
+        -------
+        Yields (str, str, bool)
+        """
+        n = len(self._storage)
+        for i, storage in enumerate(self._storage):
+            writable = i == n - 1
+            if writable_only and not writable:
+                continue
+            yield os.path.join(storage, "cache"), storage, writable
+
+    def check_file(
+        self, path: str, cfs: CachingFileSystem | None
+    ) -> Literal[False] | tuple[Detail, str]:
+        """If path is in cache return its details, otherwise return ``False``.
+
+        If the optional CachingFileSystem is specified then it is used to
+        perform extra checks to reject possible matches, such as if they are
+        too old.
+        """
+        for (fn, base, _), cache in zip(self._scan_locations(), self.cached_files):
+            if path not in cache:
+                continue
+            detail = cache[path].copy()
+
+            if cfs is not None:
+                if cfs.check_files and detail["uid"] != cfs.fs.ukey(path):
+                    # Wrong file as determined by hash of file properties
+                    continue
+                if cfs.expiry and time.time() - detail["time"] > cfs.expiry:
+                    # Cached file has expired
+                    continue
+
+            fn = os.path.join(base, detail["fn"])
+            if os.path.exists(fn):
+                return detail, fn
+        return False
+
+    def clear_expired(self, expiry_time: int) -> tuple[list[str], bool]:
+        """Remove expired metadata from the cache.
+
+        Returns names of files corresponding to expired metadata and a boolean
+        flag indicating whether the writable cache is empty. Caller is
+        responsible for deleting the expired files.
+        """
+        expired_files = []
+        for path, detail in self.cached_files[-1].copy().items():
+            if time.time() - detail["time"] > expiry_time:
+                fn = detail.get("fn", "")
+                if not fn:
+                    raise RuntimeError(
+                        f"Cache metadata does not contain 'fn' for {path}"
+                    )
+                fn = os.path.join(self._storage[-1], fn)
+                expired_files.append(fn)
+                self.cached_files[-1].pop(path)
+
+        if self.cached_files[-1]:
+            cache_path = os.path.join(self._storage[-1], "cache")
+            self._save(self.cached_files[-1], cache_path)
+
+        writable_cache_empty = not self.cached_files[-1]
+        return expired_files, writable_cache_empty
+
+    def load(self) -> None:
+        """Load all metadata from disk and store in ``self.cached_files``"""
+        cached_files = []
+        for fn, _, _ in self._scan_locations():
+            if os.path.exists(fn):
+                # TODO: consolidate blocks here
+                cached_files.append(self._load(fn))
+            else:
+                cached_files.append({})
+        self.cached_files = cached_files or [{}]
+
+    def on_close_cached_file(self, f: Any, path: str) -> None:
+        """Perform side-effect actions on closing a cached file.
+
+        The actual closing of the file is the responsibility of the caller.
+        """
+        # File must be writable, so in self.cached_files[-1]
+        c = self.cached_files[-1][path]
+        if c["blocks"] is not True and len(c["blocks"]) * f.blocksize >= f.size:
+            c["blocks"] = True
+
+    def pop_file(self, path: str) -> str | None:
+        """Remove metadata of cached file.
+
+        If path is in the cache, return the filename of the cached file,
+        otherwise return ``None``.  Caller is responsible for deleting the
+        cached file.
+        """
+        details = self.check_file(path, None)
+        if not details:
+            return None
+        _, fn = details
+        if fn.startswith(self._storage[-1]):
+            self.cached_files[-1].pop(path)
+            self.save()
+        else:
+            raise PermissionError(
+                "Can only delete cached file in last, writable cache location"
+            )
+        return fn
+
+    def save(self) -> None:
+        """Save metadata to disk"""
+        for (fn, _, writable), cache in zip(self._scan_locations(), self.cached_files):
+            if not writable:
+                continue
+
+            if os.path.exists(fn):
+                cached_files = self._load(fn)
+                for k, c in cached_files.items():
+                    if k in cache:
+                        if c["blocks"] is True or cache[k]["blocks"] is True:
+                            c["blocks"] = True
+                        else:
+                            # self.cached_files[*][*]["blocks"] must continue to
+                            # point to the same set object so that updates
+                            # performed by MMapCache are propagated back to
+                            # self.cached_files.
+                            blocks = cache[k]["blocks"]
+                            blocks.update(c["blocks"])
+                            c["blocks"] = blocks
+                        c["time"] = max(c["time"], cache[k]["time"])
+                        c["uid"] = cache[k]["uid"]
+
+                # Files can be added to cache after it was written once
+                for k, c in cache.items():
+                    if k not in cached_files:
+                        cached_files[k] = c
+            else:
+                cached_files = cache
+            cache = {k: v.copy() for k, v in cached_files.items()}
+            for c in cache.values():
+                if isinstance(c["blocks"], set):
+                    c["blocks"] = list(c["blocks"])
+            self._save(cache, fn)
+            self.cached_files[-1] = cached_files
+
+    def update_file(self, path: str, detail: Detail) -> None:
+        """Update metadata for specific file in memory, do not save"""
+        self.cached_files[-1][path] = detail
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cached.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cached.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb557884ac6998ddd9adc99855dd9426cb20f7fe
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/cached.py
@@ -0,0 +1,1083 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import os
+import tempfile
+import time
+import weakref
+from collections.abc import Callable
+from shutil import rmtree
+from typing import TYPE_CHECKING, Any, ClassVar
+
+from fsspec import filesystem
+from fsspec.callbacks import DEFAULT_CALLBACK
+from fsspec.compression import compr
+from fsspec.core import BaseCache, MMapCache
+from fsspec.exceptions import BlocksizeMismatchError
+from fsspec.implementations.cache_mapper import create_cache_mapper
+from fsspec.implementations.cache_metadata import CacheMetadata
+from fsspec.implementations.chained import ChainedFileSystem
+from fsspec.implementations.local import LocalFileSystem
+from fsspec.spec import AbstractBufferedFile
+from fsspec.transaction import Transaction
+from fsspec.utils import infer_compression
+
+if TYPE_CHECKING:
+    from fsspec.implementations.cache_mapper import AbstractCacheMapper
+
+logger = logging.getLogger("fsspec.cached")
+
+
+class WriteCachedTransaction(Transaction):
+    def complete(self, commit=True):
+        rpaths = [f.path for f in self.files]
+        lpaths = [f.fn for f in self.files]
+        if commit:
+            self.fs.put(lpaths, rpaths)
+        self.files.clear()
+        self.fs._intrans = False
+        self.fs._transaction = None
+        self.fs = None  # break cycle
+
+
+class CachingFileSystem(ChainedFileSystem):
+    """Locally caching filesystem, layer over any other FS
+
+    This class implements chunk-wise local storage of remote files, for quick
+    access after the initial download. The files are stored in a given
+    directory with hashes of URLs for the filenames. If no directory is given,
+    a temporary one is used, which should be cleaned up by the OS after the
+    process ends. The files themselves are sparse (as implemented in
+    :class:`~fsspec.caching.MMapCache`), so only the data which is accessed
+    takes up space.
+
+    Restrictions:
+
+    - the block-size must be the same for each access of a given file, unless
+      all blocks of the file have already been read
+    - caching can only be applied to file-systems which produce files
+      derived from fsspec.spec.AbstractBufferedFile ; LocalFileSystem is also
+      allowed, for testing
+    """
+
+    protocol: ClassVar[str | tuple[str, ...]] = ("blockcache", "cached")
+    _strip_tokenize_options = ("fo",)
+
+    def __init__(
+        self,
+        target_protocol=None,
+        cache_storage="TMP",
+        cache_check=10,
+        check_files=False,
+        expiry_time=604800,
+        target_options=None,
+        fs=None,
+        same_names: bool | None = None,
+        compression=None,
+        cache_mapper: AbstractCacheMapper | None = None,
+        cache_storage_mode=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        target_protocol: str (optional)
+            Target filesystem protocol. Provide either this or ``fs``.
+        cache_storage: str or list(str)
+            Location to store files. If "TMP", this is a temporary directory,
+            and will be cleaned up by the OS when this process ends (or later).
+            If a list, each location will be tried in the order given, but
+            only the last will be considered writable.
+        cache_check: int
+            Number of seconds between reload of cache metadata
+        check_files: bool
+            Whether to explicitly see if the UID of the remote file matches
+            the stored one before using. Warning: some file systems such as
+            HTTP cannot reliably give a unique hash of the contents of some
+            path, so be sure to set this option to False.
+        expiry_time: int
+            The time in seconds after which a local copy is considered useless.
+            Set to falsy to prevent expiry. The default is equivalent to one
+            week.
+        target_options: dict or None
+            Passed to the instantiation of the FS, if fs is None.
+        fs: filesystem instance
+            The target filesystem to run against. Provide this or ``protocol``.
+        same_names: bool (optional)
+            By default, target URLs are hashed using a ``HashCacheMapper`` so
+            that files from different backends with the same basename do not
+            conflict. If this argument is ``true``, a ``BasenameCacheMapper``
+            is used instead. Other cache mapper options are available by using
+            the ``cache_mapper`` keyword argument. Only one of this and
+            ``cache_mapper`` should be specified.
+        compression: str (optional)
+            To decompress on download. Can be 'infer' (guess from the URL name),
+            one of the entries in ``fsspec.compression.compr``, or None for no
+            decompression.
+        cache_mapper: AbstractCacheMapper (optional)
+            The object use to map from original filenames to cached filenames.
+            Only one of this and ``same_names`` should be specified.
+        cache_storage_mode: int (optional)
+            Permission mode used when creating the cache storage directory,
+            e.g. ``0o700``. The default of ``None`` leaves the directory at
+            the system default (governed by the umask), which is the existing
+            behaviour. Pass an octal mode such as ``0o700`` to keep the cache
+            directory, and so the cached data files within it, readable by the
+            owner only.
+        """
+        super().__init__(**kwargs)
+        if fs is None and target_protocol is None:
+            raise ValueError(
+                "Please provide filesystem instance(fs) or target_protocol"
+            )
+        if not (fs is None) ^ (target_protocol is None):
+            raise ValueError(
+                "Both filesystems (fs) and target_protocol may not be both given."
+            )
+        if cache_storage == "TMP":
+            tempdir = tempfile.mkdtemp()
+            storage = [tempdir]
+            weakref.finalize(self, self._remove_tempdir, tempdir)
+        else:
+            if isinstance(cache_storage, str):
+                storage = [cache_storage]
+            else:
+                storage = cache_storage
+        self.cache_storage_mode = cache_storage_mode
+        self._makedirs(storage[-1])
+        self.storage = storage
+        self.kwargs = target_options or {}
+        self.cache_check = cache_check
+        self.check_files = check_files
+        self.expiry = expiry_time
+        self.compression = compression
+
+        # Size of cache in bytes. If None then the size is unknown and will be
+        # recalculated the next time cache_size() is called. On writes to the
+        # cache this is reset to None.
+        self._cache_size = None
+
+        if same_names is not None and cache_mapper is not None:
+            raise ValueError(
+                "Cannot specify both same_names and cache_mapper in "
+                "CachingFileSystem.__init__"
+            )
+        if cache_mapper is not None:
+            self._mapper = cache_mapper
+        else:
+            self._mapper = create_cache_mapper(
+                same_names if same_names is not None else False
+            )
+
+        self.target_protocol = (
+            target_protocol
+            if isinstance(target_protocol, str)
+            else (fs.protocol if isinstance(fs.protocol, str) else fs.protocol[0])
+        )
+        self._metadata = CacheMetadata(self.storage)
+        self.load_cache()
+        self.fs = fs if fs is not None else filesystem(target_protocol, **self.kwargs)
+
+        def _strip_protocol(path):
+            # acts as a method, since each instance has a difference target
+            return self.fs._strip_protocol(type(self)._strip_protocol(path))
+
+        self._strip_protocol: Callable = _strip_protocol
+
+    @staticmethod
+    def _remove_tempdir(tempdir):
+        try:
+            rmtree(tempdir)
+        except Exception:
+            pass
+
+    def _makedirs(self, path):
+        if self.cache_storage_mode is None:
+            os.makedirs(path, exist_ok=True)
+        else:
+            os.makedirs(path, exist_ok=True, mode=self.cache_storage_mode)
+
+    def _mkcache(self):
+        self._makedirs(self.storage[-1])
+
+    def cache_size(self):
+        """Return size of cache in bytes.
+
+        If more than one cache directory is in use, only the size of the last
+        one (the writable cache directory) is returned.
+        """
+        if self._cache_size is None:
+            cache_dir = self.storage[-1]
+            self._cache_size = filesystem("file").du(cache_dir, withdirs=True)
+        return self._cache_size
+
+    def load_cache(self):
+        """Read set of stored blocks from file"""
+        self._metadata.load()
+        self._mkcache()
+        self.last_cache = time.time()
+
+    def save_cache(self):
+        """Save set of stored blocks from file"""
+        self._mkcache()
+        self._metadata.save()
+        self.last_cache = time.time()
+        self._cache_size = None
+
+    def _check_cache(self):
+        """Reload caches if time elapsed or any disappeared"""
+        self._mkcache()
+        if not self.cache_check:
+            # explicitly told not to bother checking
+            return
+        timecond = time.time() - self.last_cache > self.cache_check
+        existcond = all(os.path.exists(storage) for storage in self.storage)
+        if timecond or not existcond:
+            self.load_cache()
+
+    def _check_file(self, path):
+        """Is path in cache and still valid"""
+        path = self._strip_protocol(path)
+        self._check_cache()
+        return self._metadata.check_file(path, self)
+
+    def clear_cache(self):
+        """Remove all files and metadata from the cache
+
+        In the case of multiple cache locations, this clears only the last one,
+        which is assumed to be the read/write one.
+        """
+        rmtree(self.storage[-1])
+        self.load_cache()
+        self._cache_size = None
+
+    def clear_expired_cache(self, expiry_time=None):
+        """Remove all expired files and metadata from the cache
+
+        In the case of multiple cache locations, this clears only the last one,
+        which is assumed to be the read/write one.
+
+        Parameters
+        ----------
+        expiry_time: int
+            The time in seconds after which a local copy is considered useless.
+            If not defined the default is equivalent to the attribute from the
+            file caching instantiation.
+        """
+
+        if not expiry_time:
+            expiry_time = self.expiry
+
+        self._check_cache()
+
+        expired_files, writable_cache_empty = self._metadata.clear_expired(expiry_time)
+        for fn in expired_files:
+            if os.path.exists(fn):
+                os.remove(fn)
+
+        if writable_cache_empty:
+            rmtree(self.storage[-1])
+            self.load_cache()
+
+        self._cache_size = None
+
+    def pop_from_cache(self, path):
+        """Remove cached version of given file
+
+        Deletes local copy of the given (remote) path. If it is found in a cache
+        location which is not the last, it is assumed to be read-only, and
+        raises PermissionError
+        """
+        path = self._strip_protocol(path)
+        fn = self._metadata.pop_file(path)
+        if fn is not None:
+            os.remove(fn)
+        self._cache_size = None
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """Wrap the target _open
+
+        If the whole file exists in the cache, just open it locally and
+        return that.
+
+        Otherwise, open the file on the target FS, and make it have a mmap
+        cache pointing to the location which we determine, in our cache.
+        The ``blocks`` instance is shared, so as the mmap cache instance
+        updates, so does the entry in our ``cached_files`` attribute.
+        We monkey-patch this file, so that when it closes, we call
+        ``close_and_update`` to save the state of the blocks.
+        """
+        path = self._strip_protocol(path)
+
+        path = self.fs._strip_protocol(path)
+        if "r" not in mode:
+            return self.fs._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+        detail = self._check_file(path)
+        if detail:
+            # file is in cache
+            detail, fn = detail
+            hash, blocks = detail["fn"], detail["blocks"]
+            if blocks is True:
+                # stored file is complete
+                logger.debug("Opening local copy of %s", path)
+                return open(fn, mode)
+            # TODO: action where partial file exists in read-only cache
+            logger.debug("Opening partially cached copy of %s", path)
+        else:
+            hash = self._mapper(path)
+            fn = os.path.join(self.storage[-1], hash)
+            blocks = set()
+            detail = {
+                "original": path,
+                "fn": hash,
+                "blocks": blocks,
+                "time": time.time(),
+                "uid": self.fs.ukey(path),
+            }
+            self._metadata.update_file(path, detail)
+            logger.debug("Creating local sparse file for %s", path)
+
+        # explicitly submitting the size to the open call will avoid extra
+        # operations when opening. This is particularly relevant
+        # for any file that is read over a network, e.g. S3.
+        size = detail.get("size")
+
+        # call target filesystems open
+        self._mkcache()
+        f = self.fs._open(
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_options=cache_options,
+            cache_type="none",
+            size=size,
+            **kwargs,
+        )
+
+        # set size if not already set
+        if size is None:
+            detail["size"] = f.size
+            self._metadata.update_file(path, detail)
+
+        if self.compression:
+            comp = (
+                infer_compression(path)
+                if self.compression == "infer"
+                else self.compression
+            )
+            f = compr[comp](f, mode="rb")
+        if "blocksize" in detail:
+            if detail["blocksize"] != f.blocksize:
+                raise BlocksizeMismatchError(
+                    f"Cached file must be reopened with same block"
+                    f" size as original (old: {detail['blocksize']},"
+                    f" new {f.blocksize})"
+                )
+        else:
+            detail["blocksize"] = f.blocksize
+
+        def _fetch_ranges(ranges):
+            return self.fs.cat_ranges(
+                [path] * len(ranges),
+                [r[0] for r in ranges],
+                [r[1] for r in ranges],
+                **kwargs,
+            )
+
+        multi_fetcher = None if self.compression else _fetch_ranges
+        f.cache = MMapCache(
+            f.blocksize, f._fetch_range, f.size, fn, blocks, multi_fetcher=multi_fetcher
+        )
+        close = f.close
+        f.close = lambda: self.close_and_update(f, close)
+        self.save_cache()
+        return f
+
+    def _parent(self, path):
+        return self.fs._parent(path)
+
+    def hash_name(self, path: str, *args: Any) -> str:
+        # Kept for backward compatibility with downstream libraries.
+        # Ignores extra arguments, previously same_name boolean.
+        return self._mapper(path)
+
+    def close_and_update(self, f, close):
+        """Called when a file is closing, so store the set of blocks"""
+        if f.closed:
+            return
+        path = self._strip_protocol(f.path)
+        self._metadata.on_close_cached_file(f, path)
+        try:
+            logger.debug("going to save")
+            self.save_cache()
+            logger.debug("saved")
+        except OSError:
+            logger.debug("Cache saving failed while closing file")
+        except NameError:
+            logger.debug("Cache save failed due to interpreter shutdown")
+        close()
+        f.closed = True
+
+    def ls(self, path, detail=True, **kwargs):
+        return self.fs.ls(path, detail, **kwargs)
+
+    def __getattribute__(self, item):
+        if item in {
+            "load_cache",
+            "_get_cached_file_before_open",
+            "_open",
+            "save_cache",
+            "close_and_update",
+            "__init__",
+            "__getattribute__",
+            "__reduce__",
+            "_make_local_details",
+            "open",
+            "cat",
+            "cat_file",
+            "_cat_file",
+            "cat_ranges",
+            "_cat_ranges",
+            "_local_paths_for_ranges",
+            "get",
+            "read_block",
+            "tail",
+            "head",
+            "info",
+            "ls",
+            "exists",
+            "isfile",
+            "isdir",
+            "_check_file",
+            "_check_cache",
+            "_makedirs",
+            "_mkcache",
+            "clear_cache",
+            "clear_expired_cache",
+            "pop_from_cache",
+            "local_file",
+            "_paths_from_path",
+            "get_mapper",
+            "open_many",
+            "commit_many",
+            "hash_name",
+            "__hash__",
+            "__eq__",
+            "to_json",
+            "to_dict",
+            "cache_size",
+            "pipe_file",
+            "pipe",
+            "start_transaction",
+            "end_transaction",
+        }:
+            # all the methods defined in this class. Note `open` here, since
+            # it calls `_open`, but is actually in superclass
+            if hasattr(type(self), item):
+                return lambda *args, **kw: getattr(type(self), item).__get__(self)(
+                    *args, **kw
+                )
+            # method is in the whitelist but not defined on this subclass;
+            # fall through to delegate to the wrapped filesystem below
+        if item in ["__reduce_ex__"]:
+            raise AttributeError
+        if item in ["transaction"]:
+            # property
+            return type(self).transaction.__get__(self)
+        if item in {"_cache", "transaction_type", "protocol"}:
+            # class attributes
+            return getattr(type(self), item)
+        if item == "__class__":
+            return type(self)
+        d = object.__getattribute__(self, "__dict__")
+        fs = d.get("fs", None)  # fs is not immediately defined
+        if item in d:
+            return d[item]
+        elif fs is not None:
+            if item in fs.__dict__:
+                # attribute of instance
+                return fs.__dict__[item]
+            # attributed belonging to the target filesystem
+            cls = type(fs)
+            m = getattr(cls, item)
+            if (inspect.isfunction(m) or inspect.isdatadescriptor(m)) and (
+                not hasattr(m, "__self__") or m.__self__ is None
+            ):
+                # instance method
+                return m.__get__(fs, cls)
+            return m  # class method or attribute
+        else:
+            # attributes of the superclass, while target is being set up
+            return super().__getattribute__(item)
+
+    def __eq__(self, other):
+        """Test for equality."""
+        if self is other:
+            return True
+        if not isinstance(other, type(self)):
+            return False
+        return (
+            self.storage == other.storage
+            and self.kwargs == other.kwargs
+            and self.cache_check == other.cache_check
+            and self.check_files == other.check_files
+            and self.expiry == other.expiry
+            and self.compression == other.compression
+            and self._mapper == other._mapper
+            and self.target_protocol == other.target_protocol
+        )
+
+    def __hash__(self):
+        """Calculate hash."""
+        return (
+            hash(tuple(self.storage))
+            ^ hash(str(self.kwargs))
+            ^ hash(self.cache_check)
+            ^ hash(self.check_files)
+            ^ hash(self.expiry)
+            ^ hash(self.compression)
+            ^ hash(self._mapper)
+            ^ hash(self.target_protocol)
+        )
+
+
+class WholeFileCacheFileSystem(CachingFileSystem):
+    """Caches whole remote files on first access
+
+    This class is intended as a layer over any other file system, and
+    will make a local copy of each file accessed, so that all subsequent
+    reads are local. This is similar to ``CachingFileSystem``, but without
+    the block-wise functionality and so can work even when sparse files
+    are not allowed. See its docstring for definition of the init
+    arguments.
+
+    The class still needs access to the remote store for listing files,
+    and may refresh cached files.
+    """
+
+    protocol = "filecache"
+    local_file = True
+
+    def open_many(self, open_files, **kwargs):
+        paths = [of.path for of in open_files]
+        if "r" in open_files.mode:
+            self._mkcache()
+        else:
+            return [
+                LocalTempFile(
+                    self.fs,
+                    path,
+                    mode=open_files.mode,
+                    fn=os.path.join(self.storage[-1], self._mapper(path)),
+                    **kwargs,
+                )
+                for path in paths
+            ]
+
+        if self.compression:
+            raise NotImplementedError
+        details = [self._check_file(sp) for sp in paths]
+        downpath = [p for p, d in zip(paths, details) if not d]
+        downfn0 = [
+            os.path.join(self.storage[-1], self._mapper(p))
+            for p, d in zip(paths, details)
+        ]  # keep these path names for opening later
+        downfn = [fn for fn, d in zip(downfn0, details) if not d]
+        if downpath:
+            # skip if all files are already cached and up to date
+            self.fs.get(downpath, downfn)
+
+            # update metadata - only happens when downloads are successful
+            newdetail = [
+                {
+                    "original": path,
+                    "fn": self._mapper(path),
+                    "blocks": True,
+                    "time": time.time(),
+                    "uid": self.fs.ukey(path),
+                }
+                for path in downpath
+            ]
+            for path, detail in zip(downpath, newdetail):
+                self._metadata.update_file(path, detail)
+            self.save_cache()
+
+        def firstpart(fn):
+            # helper to adapt both whole-file and simple-cache
+            return fn[1] if isinstance(fn, tuple) else fn
+
+        return [
+            open(firstpart(fn0) if fn0 else fn1, mode=open_files.mode)
+            for fn0, fn1 in zip(details, downfn0)
+        ]
+
+    def commit_many(self, open_files):
+        self.fs.put([f.fn for f in open_files], [f.path for f in open_files])
+        [f.close() for f in open_files]
+        for f in open_files:
+            # in case autocommit is off, and so close did not already delete
+            try:
+                os.remove(f.name)
+            except FileNotFoundError:
+                pass
+        self._cache_size = None
+
+    def _make_local_details(self, path):
+        hash = self._mapper(path)
+        fn = os.path.join(self.storage[-1], hash)
+        detail = {
+            "original": path,
+            "fn": hash,
+            "blocks": True,
+            "time": time.time(),
+            "uid": self.fs.ukey(path),
+        }
+        self._metadata.update_file(path, detail)
+        logger.debug("Copying %s to local cache", path)
+        return fn
+
+    def cat(
+        self,
+        path,
+        recursive=False,
+        on_error="raise",
+        callback=DEFAULT_CALLBACK,
+        **kwargs,
+    ):
+        paths = self.expand_path(
+            path, recursive=recursive, maxdepth=kwargs.get("maxdepth")
+        )
+        getpaths = []
+        storepaths = []
+        fns = []
+        out = {}
+        for p in paths.copy():
+            try:
+                detail = self._check_file(p)
+                if not detail:
+                    fn = self._make_local_details(p)
+                    getpaths.append(p)
+                    storepaths.append(fn)
+                else:
+                    detail, fn = detail if isinstance(detail, tuple) else (None, detail)
+                fns.append(fn)
+            except Exception as e:
+                if on_error == "raise":
+                    raise
+                if on_error == "return":
+                    out[p] = e
+                paths.remove(p)
+
+        if getpaths:
+            self.fs.get(getpaths, storepaths)
+            self.save_cache()
+
+        callback.set_size(len(paths))
+        for p, fn in zip(paths, fns):
+            with open(fn, "rb") as f:
+                out[p] = f.read()
+            callback.relative_update(1)
+        if isinstance(path, str) and len(paths) == 1 and recursive is False:
+            out = out[paths[0]]
+        return out
+
+    def _get_cached_file_before_open(self, path, **kwargs):
+        fn = self._make_local_details(path)
+        # call target filesystems open
+        self._mkcache()
+        if self.compression:
+            with self.fs._open(path, mode="rb", **kwargs) as f, open(fn, "wb") as f2:
+                if isinstance(f, AbstractBufferedFile):
+                    # want no type of caching if just downloading whole thing
+                    f.cache = BaseCache(0, f.cache.fetcher, f.size)
+                comp = (
+                    infer_compression(path)
+                    if self.compression == "infer"
+                    else self.compression
+                )
+                f = compr[comp](f, mode="rb")
+                data = True
+                while data:
+                    block = getattr(f, "blocksize", 5 * 2**20)
+                    data = f.read(block)
+                    f2.write(data)
+        else:
+            self.fs.get_file(path, fn)
+        self.save_cache()
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        # For read (or append), (try) download from remote
+        if "r" in mode or "a" in mode:
+            if not self._check_file(path):
+                if self.fs.exists(path):
+                    self._get_cached_file_before_open(path, **kwargs)
+                elif "r" in mode:
+                    raise FileNotFoundError(path)
+
+            detail, fn = self._check_file(path)
+            _, blocks = detail["fn"], detail["blocks"]
+            if blocks is True:
+                logger.debug("Opening local copy of %s", path)
+            else:
+                raise ValueError(
+                    f"Attempt to open partially cached file {path}"
+                    f" as a wholly cached file"
+                )
+
+        # Just reading does not need special file handling
+        if "r" in mode and "+" not in mode:
+            # In order to support downstream filesystems to be able to
+            # infer the compression from the original filename, like
+            # the `TarFileSystem`, let's extend the `io.BufferedReader`
+            # fileobject protocol by adding a dedicated attribute
+            # `original`.
+            f = open(fn, mode)
+            f.original = detail.get("original")
+            return f
+
+        hash = self._mapper(path)
+        fn = os.path.join(self.storage[-1], hash)
+        user_specified_kwargs = {
+            k: v
+            for k, v in kwargs.items()
+            # those kwargs were added by open(), we don't want them
+            if k not in ["autocommit", "block_size", "cache_options"]
+        }
+        return LocalTempFile(self, path, mode=mode, fn=fn, **user_specified_kwargs)
+
+    async def _cat_file(self, path, start=None, end=None, **kwargs):
+        logger.debug("async cat_file %s", path)
+        path = self._strip_protocol(path)
+        sha = self._mapper(path)
+        fn = self._check_file(path)
+
+        if not fn:
+            fn = os.path.join(self.storage[-1], sha)
+            await self.fs._get_file(path, fn, **kwargs)
+
+        with open(fn, "rb") as f:  # noqa ASYNC230
+            if start:
+                f.seek(start)
+            size = -1 if end is None else end - f.tell()
+            return f.read(size)
+
+    def _local_paths_for_ranges(self, paths):
+        """Cache file for each of paths, and which remote files to download
+
+        A path given more than once is downloaded once, and every occurrence
+        reads from the same cache file.
+        """
+        lpaths = []
+        local = {}
+        download = []
+        rpaths = []
+        for p in paths:
+            if p not in local:
+                detail = self._check_file(p)
+                if not detail:
+                    fn = os.path.join(self.storage[-1], self._mapper(p))
+                    download.append(fn)
+                    rpaths.append(p)
+                else:
+                    # filecache returns (detail, fn), simplecache just fn
+                    fn = detail[1] if isinstance(detail, tuple) else detail
+                local[p] = fn
+            lpaths.append(local[p])
+        return lpaths, rpaths, download
+
+    async def _cat_ranges(
+        self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+    ):
+        logger.debug("async cat ranges %s", paths)
+        lpaths, rpaths, download = self._local_paths_for_ranges(paths)
+        if download:
+            await self.fs._get(rpaths, download)
+
+        return LocalFileSystem().cat_ranges(
+            lpaths, starts, ends, max_gap=max_gap, on_error=on_error, **kwargs
+        )
+
+
+class SimpleCacheFileSystem(WholeFileCacheFileSystem):
+    """Caches whole remote files on first access
+
+    This class is intended as a layer over any other file system, and
+    will make a local copy of each file accessed, so that all subsequent
+    reads are local. This implementation only copies whole files, and
+    does not keep any metadata about the download time or file details.
+    It is therefore safer to use in multi-threaded/concurrent situations.
+
+    This is the only of the caching filesystems that supports write: you will
+    be given a real local open file, and upon close and commit, it will be
+    uploaded to the target filesystem; the writability or the target URL is
+    not checked until that time.
+
+    """
+
+    protocol = "simplecache"
+    local_file = True
+    transaction_type = WriteCachedTransaction
+
+    def __init__(self, **kwargs):
+        kw = kwargs.copy()
+        for key in ["cache_check", "expiry_time", "check_files"]:
+            kw[key] = False
+        super().__init__(**kw)
+        for storage in self.storage:
+            if not os.path.exists(storage):
+                self._makedirs(storage)
+
+    def _check_file(self, path):
+        self._check_cache()
+        sha = self._mapper(path)
+        for storage in self.storage:
+            fn = os.path.join(storage, sha)
+            if os.path.exists(fn):
+                return fn
+
+    def save_cache(self):
+        pass
+
+    def load_cache(self):
+        pass
+
+    def clear_expired_cache(self, expiry_time=None):
+        """Remove cached files older than ``expiry_time`` seconds.
+
+        SimpleCache does not store metadata, so cached file modification times
+        are used instead. Only the last (writable) cache location is changed.
+
+        Parameters
+        ----------
+        expiry_time: int or float
+            Maximum age of a cached file in seconds. This must be supplied
+            explicitly because SimpleCache has no configured expiry time.
+        """
+        if expiry_time is None:
+            raise ValueError("expiry_time must be provided for simplecache")
+        if expiry_time < 0:
+            raise ValueError("expiry_time must be non-negative")
+
+        self._mkcache()
+        cutoff = time.time() - expiry_time
+        with os.scandir(self.storage[-1]) as entries:
+            for entry in entries:
+                try:
+                    if (
+                        entry.is_file(follow_symlinks=False)
+                        and entry.stat(follow_symlinks=False).st_mtime < cutoff
+                    ):
+                        os.remove(entry.path)
+                except FileNotFoundError:
+                    # Another process may be using the same simple cache.
+                    pass
+        self._cache_size = None
+
+    def pipe_file(self, path, value=None, **kwargs):
+        if self._intrans:
+            with self.open(path, "wb") as f:
+                f.write(value)
+        else:
+            super().pipe_file(path, value)
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        details = []
+        try:
+            details = self.fs.ls(
+                path, detail=True, **kwargs
+            ).copy()  # don't edit original!
+        except FileNotFoundError as e:
+            ex = e
+        else:
+            ex = None
+        if self._intrans:
+            path1 = path.rstrip("/") + "/"
+            for f in self.transaction.files:
+                if f.path == path:
+                    details.append(
+                        {"name": path, "size": f.size or f.tell(), "type": "file"}
+                    )
+                elif f.path.startswith(path1):
+                    if f.path.count("/") == path1.count("/"):
+                        details.append(
+                            {"name": f.path, "size": f.size or f.tell(), "type": "file"}
+                        )
+                    else:
+                        dname = "/".join(f.path.split("/")[: path1.count("/") + 1])
+                        details.append({"name": dname, "size": 0, "type": "directory"})
+        if ex is not None and not details:
+            raise ex
+        if detail:
+            return details
+        return sorted(_["name"] for _ in details)
+
+    def info(self, path, **kwargs):
+        path = self._strip_protocol(path)
+        if self._intrans:
+            f = [_ for _ in self.transaction.files if _.path == path]
+            if f:
+                size = os.path.getsize(f[0].fn) if f[0].closed else f[0].tell()
+                return {"name": path, "size": size, "type": "file"}
+            f = any(_.path.startswith(path + "/") for _ in self.transaction.files)
+            if f:
+                return {"name": path, "size": 0, "type": "directory"}
+        return self.fs.info(path, **kwargs)
+
+    def pipe(self, path, value=None, **kwargs):
+        if isinstance(path, str):
+            self.pipe_file(self._strip_protocol(path), value, **kwargs)
+        elif isinstance(path, dict):
+            for k, v in path.items():
+                self.pipe_file(self._strip_protocol(k), v, **kwargs)
+        else:
+            raise ValueError("path must be str or dict")
+
+    def cat_ranges(
+        self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+    ):
+        logger.debug("cat ranges %s", paths)
+        lpaths, rpaths, download = self._local_paths_for_ranges(paths)
+        if download:
+            self.fs.get(rpaths, download)
+        return LocalFileSystem().cat_ranges(
+            lpaths, starts, ends, max_gap=max_gap, on_error=on_error, **kwargs
+        )
+
+    def _get_cached_file_before_open(self, path, **kwargs):
+        sha = self._mapper(path)
+        fn = os.path.join(self.storage[-1], sha)
+        logger.debug("Copying %s to local cache", path)
+
+        self._mkcache()
+        self._cache_size = None
+
+        if self.compression:
+            with self.fs._open(path, mode="rb", **kwargs) as f, open(fn, "wb") as f2:
+                if isinstance(f, AbstractBufferedFile):
+                    # want no type of caching if just downloading whole thing
+                    f.cache = BaseCache(0, f.cache.fetcher, f.size)
+                comp = (
+                    infer_compression(path)
+                    if self.compression == "infer"
+                    else self.compression
+                )
+                f = compr[comp](f, mode="rb")
+                data = True
+                while data:
+                    block = getattr(f, "blocksize", 5 * 2**20)
+                    data = f.read(block)
+                    f2.write(data)
+        else:
+            self.fs.get_file(path, fn)
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        sha = self._mapper(path)
+
+        # For read (or append), (try) download from remote
+        if "r" in mode or "a" in mode:
+            if not self._check_file(path):
+                # append does not require an existing file but read does
+                if self.fs.exists(path):
+                    self._get_cached_file_before_open(path, **kwargs)
+                elif "r" in mode:
+                    raise FileNotFoundError(path)
+
+        fn = self._check_file(path)
+        # Just reading does not need special file handling
+        if "r" in mode and "+" not in mode:
+            return open(fn, mode)
+
+        fn = os.path.join(self.storage[-1], sha)
+        user_specified_kwargs = {
+            k: v
+            for k, v in kwargs.items()
+            if k not in ["autocommit", "block_size", "cache_options"]
+        }  # those were added by open()
+        return LocalTempFile(
+            self,
+            path,
+            mode=mode,
+            autocommit=not self._intrans,
+            fn=fn,
+            **user_specified_kwargs,
+        )
+
+
+class LocalTempFile:
+    """A temporary local file, which will be uploaded on commit"""
+
+    def __init__(self, fs, path, fn, mode="wb", autocommit=True, seek=0, **kwargs):
+        self.fn = fn
+        self.fh = open(fn, mode)
+        self.mode = mode
+        if seek:
+            self.fh.seek(seek)
+        self.path = path
+        self.size = None
+        self.fs = fs
+        self.closed = False
+        self.autocommit = autocommit
+        self.kwargs = kwargs
+
+    def __reduce__(self):
+        # always open in r+b to allow continuing writing at a location
+        return (
+            LocalTempFile,
+            (self.fs, self.path, self.fn, "r+b", self.autocommit, self.tell()),
+        )
+
+    def __enter__(self):
+        return self.fh
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()
+
+    def close(self):
+        # self.size = self.fh.tell()
+        if self.closed:
+            return
+        self.fh.close()
+        self.closed = True
+        if self.autocommit:
+            self.commit()
+
+    def discard(self):
+        self.fh.close()
+        os.remove(self.fn)
+
+    def commit(self):
+        # calling put() with list arguments avoids path expansion and additional operations
+        # like isdir()
+        self.fs.put([self.fn], [self.path], **self.kwargs)
+        # we do not delete the local copy, it's still in the cache.
+
+    @property
+    def name(self):
+        return self.fn
+
+    def __repr__(self) -> str:
+        return f"LocalTempFile: {self.path}"
+
+    def __getattr__(self, item):
+        return getattr(self.fh, item)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/chained.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/chained.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfce64334e8db0272eefa96b4428b23524b059f0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/chained.py
@@ -0,0 +1,23 @@
+from typing import ClassVar
+
+from fsspec import AbstractFileSystem
+
+__all__ = ("ChainedFileSystem",)
+
+
+class ChainedFileSystem(AbstractFileSystem):
+    """Chained filesystem base class.
+
+    A chained filesystem is designed to be layered over another FS.
+    This is useful to implement things like caching.
+
+    This base class does very little on its own, but is used as a marker
+    that the class is designed for chaining.
+
+    Right now this is only used in `url_to_fs` to provide the path argument
+    (`fo`) to the chained filesystem from the underlying filesystem.
+
+    Additional functionality may be added in the future.
+    """
+
+    protocol: ClassVar[str] = "chained"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dask.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dask.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e1276463db6866665e6a0fe114efc247971b57e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dask.py
@@ -0,0 +1,152 @@
+import dask
+from distributed.client import Client, _get_global_client
+from distributed.worker import Worker
+
+from fsspec import filesystem
+from fsspec.spec import AbstractBufferedFile, AbstractFileSystem
+from fsspec.utils import infer_storage_options
+
+
+def _get_client(client):
+    if client is None:
+        return _get_global_client()
+    elif isinstance(client, Client):
+        return client
+    else:
+        # e.g., connection string
+        return Client(client)
+
+
+def _in_worker():
+    return bool(Worker._instances)
+
+
+class DaskWorkerFileSystem(AbstractFileSystem):
+    """View files accessible to a worker as any other remote file-system
+
+    When instances are run on the worker, uses the real filesystem. When
+    run on the client, they call the worker to provide information or data.
+
+    **Warning** this implementation is experimental, and read-only for now.
+    """
+
+    def __init__(
+        self, target_protocol=None, target_options=None, fs=None, client=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+        if not (fs is None) ^ (target_protocol is None):
+            raise ValueError(
+                "Please provide one of filesystem instance (fs) or"
+                " target_protocol, not both"
+            )
+        self.target_protocol = target_protocol
+        self.target_options = target_options
+        self.worker = None
+        self.client = client
+        self.fs = fs
+        self._determine_worker()
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        so = infer_storage_options(path)
+        if "host" in so and "port" in so:
+            return {"client": f"{so['host']}:{so['port']}"}
+        else:
+            return {}
+
+    def _determine_worker(self):
+        if _in_worker():
+            self.worker = True
+            if self.fs is None:
+                self.fs = filesystem(
+                    self.target_protocol, **(self.target_options or {})
+                )
+        else:
+            self.worker = False
+            self.client = _get_client(self.client)
+            self.rfs = dask.delayed(self)
+
+    def mkdir(self, *args, **kwargs):
+        if self.worker:
+            self.fs.mkdir(*args, **kwargs)
+        else:
+            self.rfs.mkdir(*args, **kwargs).compute()
+
+    def rm(self, *args, **kwargs):
+        if self.worker:
+            self.fs.rm(*args, **kwargs)
+        else:
+            self.rfs.rm(*args, **kwargs).compute()
+
+    def copy(self, *args, **kwargs):
+        if self.worker:
+            self.fs.copy(*args, **kwargs)
+        else:
+            self.rfs.copy(*args, **kwargs).compute()
+
+    def mv(self, *args, **kwargs):
+        if self.worker:
+            self.fs.mv(*args, **kwargs)
+        else:
+            self.rfs.mv(*args, **kwargs).compute()
+
+    def ls(self, *args, **kwargs):
+        if self.worker:
+            return self.fs.ls(*args, **kwargs)
+        else:
+            return self.rfs.ls(*args, **kwargs).compute()
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        if self.worker:
+            return self.fs._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+        else:
+            return DaskFile(
+                fs=self,
+                path=path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=autocommit,
+                cache_options=cache_options,
+                **kwargs,
+            )
+
+    def fetch_range(self, path, mode, start, end):
+        if self.worker:
+            with self._open(path, mode) as f:
+                f.seek(start)
+                return f.read(end - start)
+        else:
+            return self.rfs.fetch_range(path, mode, start, end).compute()
+
+
+class DaskFile(AbstractBufferedFile):
+    def __init__(self, mode="rb", **kwargs):
+        if mode != "rb":
+            raise ValueError('Remote dask files can only be opened in "rb" mode')
+        super().__init__(**kwargs)
+
+    def _upload_chunk(self, final=False):
+        pass
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        pass
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        return self.fs.fetch_range(self.path, self.mode, start, end)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/data.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/data.py
new file mode 100644
index 0000000000000000000000000000000000000000..fad1b56d0940a6e5232497475ab32a504e19ec9a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/data.py
@@ -0,0 +1,71 @@
+import base64
+import io
+from urllib.parse import unquote
+
+from fsspec import AbstractFileSystem
+from fsspec.utils import stringify_path
+
+
+class DataFileSystem(AbstractFileSystem):
+    """A handy decoder for data-URLs
+
+    Example
+    -------
+    >>> with fsspec.open("data:,Hello%2C%20World%21") as f:
+    ...     print(f.read())
+    b"Hello, World!"
+
+    See https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs
+    """
+
+    protocol = "data"
+
+    def __init__(self, **kwargs):
+        """No parameters for this filesystem"""
+        super().__init__(**kwargs)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        if isinstance(path, list):
+            return [cls._strip_protocol(p) for p in path]
+        path = stringify_path(path)
+        if path.startswith("data://"):
+            path = path[7:]
+        elif path.startswith("data:"):
+            path = path[5:]
+        # Do NOT strip trailing slashes, as they may be meaningful base64 characters
+        # or percent-encoded data content
+        return path
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        pref, data = path.split(",", 1)
+        if pref.endswith("base64"):
+            return base64.b64decode(data)[start:end]
+        return unquote(data).encode()[start:end]
+
+    def info(self, path, **kwargs):
+        pref, name = path.split(",", 1)
+        data = self.cat_file(path)
+        mime = pref.split(":", 1)[1].split(";", 1)[0]
+        return {"name": name, "size": len(data), "type": "file", "mimetype": mime}
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        if "r" not in mode:
+            raise ValueError("Read only filesystem")
+        return io.BytesIO(self.cat_file(path))
+
+    @staticmethod
+    def encode(data: bytes, mime: str | None = None):
+        """Format the given data into data-URL syntax
+
+        This version always base64 encodes, even when the data is ascii/url-safe.
+        """
+        return f"data:{mime or ''};base64,{base64.b64encode(data).decode()}"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dbfs.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dbfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b7f03f66c94dccf7880546728ce1c3f110bc10a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dbfs.py
@@ -0,0 +1,497 @@
+from __future__ import annotations
+
+import base64
+import urllib
+
+import requests
+from requests.adapters import HTTPAdapter, Retry
+from typing_extensions import override
+
+from fsspec import AbstractFileSystem
+from fsspec.spec import AbstractBufferedFile
+
+
+class DatabricksException(Exception):
+    """
+    Helper class for exceptions raised in this module.
+    """
+
+    def __init__(self, error_code, message, details=None):
+        """Create a new DatabricksException"""
+        super().__init__(message)
+
+        self.error_code = error_code
+        self.message = message
+        self.details = details
+
+
+class DatabricksFileSystem(AbstractFileSystem):
+    """
+    Get access to the Databricks filesystem implementation over HTTP.
+    Can be used inside and outside of a databricks cluster.
+    """
+
+    def __init__(self, instance, token, **kwargs):
+        """
+        Create a new DatabricksFileSystem.
+
+        Parameters
+        ----------
+        instance: str
+            The instance URL of the databricks cluster.
+            For example for an Azure databricks cluster, this
+            has the form adb-<some-number>.<two digits>.azuredatabricks.net.
+        token: str
+            Your personal token. Find out more
+            here: https://docs.databricks.com/dev-tools/api/latest/authentication.html
+        """
+        self.instance = instance
+        self.token = token
+        self.session = requests.Session()
+        self.retries = Retry(
+            total=10,
+            backoff_factor=0.05,
+            status_forcelist=[408, 429, 500, 502, 503, 504],
+        )
+
+        self.session.mount("https://", HTTPAdapter(max_retries=self.retries))
+        self.session.headers.update({"Authorization": f"Bearer {self.token}"})
+
+        super().__init__(**kwargs)
+
+    @override
+    def _ls_from_cache(self, path) -> list[dict[str, str | int]] | None:
+        """Check cache for listing
+
+        Returns listing, if found (may be empty list for a directory that
+        exists but contains nothing), None if not in cache.
+        """
+        self.dircache.pop(path.rstrip("/"), None)
+
+        parent = self._parent(path)
+        if parent in self.dircache:
+            for entry in self.dircache[parent]:
+                if entry["name"] == path.rstrip("/"):
+                    if entry["type"] != "directory":
+                        return [entry]
+                    return []
+            raise FileNotFoundError(path)
+
+    def ls(self, path, detail=True, **kwargs):
+        """
+        List the contents of the given path.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path
+        detail: bool
+            Return not only the list of filenames,
+            but also additional information on file sizes
+            and types.
+        """
+        try:
+            out = self._ls_from_cache(path)
+        except FileNotFoundError:
+            # This happens if the `path`'s parent was cached, but `path` is not
+            # there. This suggests that `path` is new since the parent was
+            # cached. Attempt to invalidate parent's cache before continuing.
+            self.dircache.pop(self._parent(path), None)
+            out = None
+
+        if not out:
+            try:
+                r = self._send_to_api(
+                    method="get", endpoint="list", json={"path": path}
+                )
+            except DatabricksException as e:
+                if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                    raise FileNotFoundError(e.message) from e
+
+                raise
+            files = r.get("files", [])
+            out = [
+                {
+                    "name": o["path"],
+                    "type": "directory" if o["is_dir"] else "file",
+                    "size": o["file_size"],
+                }
+                for o in files
+            ]
+            self.dircache[path] = out
+
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def makedirs(self, path, exist_ok=True):
+        """
+        Create a given absolute path and all of its parents.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to create
+        exist_ok: bool
+            If false, checks if the folder
+            exists before creating it (and raises an
+            Exception if this is the case)
+        """
+        if not exist_ok:
+            try:
+                # If the following succeeds, the path is already present
+                self._send_to_api(
+                    method="get", endpoint="get-status", json={"path": path}
+                )
+                raise FileExistsError(f"Path {path} already exists")
+            except DatabricksException as e:
+                if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                    pass
+
+        try:
+            self._send_to_api(method="post", endpoint="mkdirs", json={"path": path})
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message) from e
+
+            raise
+        self.invalidate_cache(self._parent(path))
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        """
+        Create a given absolute path and all of its parents.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to create
+        create_parents: bool
+            Whether to create all parents or not.
+            "False" is not implemented so far.
+        """
+        if not create_parents:
+            raise NotImplementedError
+
+        self.mkdirs(path, **kwargs)
+
+    def rm(self, path, recursive=False, **kwargs):
+        """
+        Remove the file or folder at the given absolute path.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path what to remove
+        recursive: bool
+            Recursively delete all files in a folder.
+        """
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="delete",
+                json={"path": path, "recursive": recursive},
+            )
+        except DatabricksException as e:
+            # This is not really an exception, it just means
+            # not everything was deleted so far
+            if e.error_code == "PARTIAL_DELETE":
+                self.rm(path=path, recursive=recursive)
+            elif e.error_code == "IO_ERROR":
+                # Using the same exception as the os module would use here
+                raise OSError(e.message) from e
+
+            raise
+        self.invalidate_cache(self._parent(path))
+
+    def mv(
+        self, source_path, destination_path, recursive=False, maxdepth=None, **kwargs
+    ):
+        """
+        Move a source to a destination path.
+
+        A note from the original [databricks API manual]
+        (https://docs.databricks.com/dev-tools/api/latest/dbfs.html#move).
+
+        When moving a large number of files the API call will time out after
+        approximately 60s, potentially resulting in partially moved data.
+        Therefore, for operations that move more than 10k files, we strongly
+        discourage using the DBFS REST API.
+
+        Parameters
+        ----------
+        source_path: str
+            From where to move (absolute path)
+        destination_path: str
+            To where to move (absolute path)
+        recursive: bool
+            Not implemented to far.
+        maxdepth:
+            Not implemented to far.
+        """
+        if recursive:
+            raise NotImplementedError
+        if maxdepth:
+            raise NotImplementedError
+
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="move",
+                json={"source_path": source_path, "destination_path": destination_path},
+            )
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message) from e
+            elif e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message) from e
+
+            raise
+        self.invalidate_cache(self._parent(source_path))
+        self.invalidate_cache(self._parent(destination_path))
+
+    def _open(self, path, mode="rb", block_size="default", **kwargs):
+        """
+        Overwrite the base class method to make sure to create a DBFile.
+        All arguments are copied from the base method.
+
+        Only the default blocksize is allowed.
+        """
+        return DatabricksFile(self, path, mode=mode, block_size=block_size, **kwargs)
+
+    def _send_to_api(self, method, endpoint, json):
+        """
+        Send the given json to the DBFS API
+        using a get or post request (specified by the argument `method`).
+
+        Parameters
+        ----------
+        method: str
+            Which http method to use for communication; "get" or "post".
+        endpoint: str
+            Where to send the request to (last part of the API URL)
+        json: dict
+            Dictionary of information to send
+        """
+        if method == "post":
+            session_call = self.session.post
+        elif method == "get":
+            session_call = self.session.get
+        else:
+            raise ValueError(f"Do not understand method {method}")
+
+        url = urllib.parse.urljoin(f"https://{self.instance}/api/2.0/dbfs/", endpoint)
+
+        r = session_call(url, json=json)
+
+        # The DBFS API will return a json, also in case of an exception.
+        # We want to preserve this information as good as possible.
+        try:
+            r.raise_for_status()
+        except requests.HTTPError as e:
+            # try to extract json error message
+            # if that fails, fall back to the original exception
+            try:
+                exception_json = e.response.json()
+            except Exception:
+                raise e from None
+
+            raise DatabricksException(**exception_json) from e
+
+        return r.json()
+
+    def _create_handle(self, path, overwrite=True):
+        """
+        Internal function to create a handle, which can be used to
+        write blocks of a file to DBFS.
+        A handle has a unique identifier which needs to be passed
+        whenever written during this transaction.
+        The handle is active for 10 minutes - after that a new
+        write transaction needs to be created.
+        Make sure to close the handle after you are finished.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path for this file.
+        overwrite: bool
+            If a file already exist at this location, either overwrite
+            it or raise an exception.
+        """
+        try:
+            r = self._send_to_api(
+                method="post",
+                endpoint="create",
+                json={"path": path, "overwrite": overwrite},
+            )
+            return r["handle"]
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_ALREADY_EXISTS":
+                raise FileExistsError(e.message) from e
+
+            raise
+
+    def _close_handle(self, handle):
+        """
+        Close a handle, which was opened by :func:`_create_handle`.
+
+        Parameters
+        ----------
+        handle: str
+            Which handle to close.
+        """
+        try:
+            self._send_to_api(method="post", endpoint="close", json={"handle": handle})
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message) from e
+
+            raise
+
+    def _add_data(self, handle, data):
+        """
+        Upload data to an already opened file handle
+        (opened by :func:`_create_handle`).
+        The maximal allowed data size is 1MB after
+        conversion to base64.
+        Remember to close the handle when you are finished.
+
+        Parameters
+        ----------
+        handle: str
+            Which handle to upload data to.
+        data: bytes
+            Block of data to add to the handle.
+        """
+        data = base64.b64encode(data).decode()
+        try:
+            self._send_to_api(
+                method="post",
+                endpoint="add-block",
+                json={"handle": handle, "data": data},
+            )
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message) from e
+            elif e.error_code == "MAX_BLOCK_SIZE_EXCEEDED":
+                raise ValueError(e.message) from e
+
+            raise
+
+    def _get_data(self, path, start, end):
+        """
+        Download data in bytes from a given absolute path in a block
+        from [start, start+length].
+        The maximum number of allowed bytes to read is 1MB.
+
+        Parameters
+        ----------
+        path: str
+            Absolute path to download data from
+        start: int
+            Start position of the block
+        end: int
+            End position of the block
+        """
+        try:
+            r = self._send_to_api(
+                method="get",
+                endpoint="read",
+                json={"path": path, "offset": start, "length": end - start},
+            )
+            return base64.b64decode(r["data"])
+        except DatabricksException as e:
+            if e.error_code == "RESOURCE_DOES_NOT_EXIST":
+                raise FileNotFoundError(e.message) from e
+            elif e.error_code in ["INVALID_PARAMETER_VALUE", "MAX_READ_SIZE_EXCEEDED"]:
+                raise ValueError(e.message) from e
+
+            raise
+
+    def invalidate_cache(self, path=None):
+        if path is None:
+            self.dircache.clear()
+        else:
+            self.dircache.pop(path, None)
+        super().invalidate_cache(path)
+
+
+class DatabricksFile(AbstractBufferedFile):
+    """
+    Helper class for files referenced in the DatabricksFileSystem.
+    """
+
+    DEFAULT_BLOCK_SIZE = 1 * 2**20  # only allowed block size
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        **kwargs,
+    ):
+        """
+        Create a new instance of the DatabricksFile.
+
+        The blocksize needs to be the default one.
+        """
+        if block_size is None or block_size == "default":
+            block_size = self.DEFAULT_BLOCK_SIZE
+
+        if block_size != self.DEFAULT_BLOCK_SIZE:
+            raise ValueError(
+                f"Only the default block size is allowed, not {block_size}"
+            )
+
+        super().__init__(
+            fs,
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_type=cache_type,
+            cache_options=cache_options or {},
+            **kwargs,
+        )
+
+    def _initiate_upload(self):
+        """Internal function to start a file upload"""
+        self.handle = self.fs._create_handle(self.path)
+
+    def _upload_chunk(self, final=False):
+        """Internal function to add a chunk of data to a started upload"""
+        self.buffer.seek(0)
+        data = self.buffer.getvalue()
+
+        data_chunks = [
+            data[start:end] for start, end in self._to_sized_blocks(len(data))
+        ]
+
+        for data_chunk in data_chunks:
+            self.fs._add_data(handle=self.handle, data=data_chunk)
+
+        if final:
+            self.fs._close_handle(handle=self.handle)
+            return True
+
+    def _fetch_range(self, start, end):
+        """Internal function to download a block of data"""
+        return_buffer = b""
+        length = end - start
+        for chunk_start, chunk_end in self._to_sized_blocks(length, start):
+            return_buffer += self.fs._get_data(
+                path=self.path, start=chunk_start, end=chunk_end
+            )
+
+        return return_buffer
+
+    def _to_sized_blocks(self, length, start=0):
+        """Helper function to split a range from 0 to total_length into blocksizes"""
+        end = start + length
+        for data_chunk in range(start, end, self.blocksize):
+            data_start = data_chunk
+            data_end = min(end, data_chunk + self.blocksize)
+            yield data_start, data_end
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dirfs.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dirfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0a48558a90b4dd43a5d9b989185abe86f469e8f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/dirfs.py
@@ -0,0 +1,478 @@
+from .. import filesystem
+from ..asyn import AsyncFileSystem
+from .chained import ChainedFileSystem
+from .local import LocalFileSystem
+
+
+def _escapes_root(path):
+    """Whether a relative path would resolve above its root via ".." segments."""
+    depth = 0
+    for part in path.split("/"):
+        if part == "..":
+            depth -= 1
+            if depth < 0:
+                return True
+        elif part and part != ".":
+            depth += 1
+    return False
+
+
+class DirFileSystem(AsyncFileSystem, ChainedFileSystem):
+    """Directory prefix filesystem
+
+    The DirFileSystem is a filesystem-wrapper. It assumes every path it is dealing with
+    is relative to the `path`. After performing the necessary paths operation it
+    delegates everything to the wrapped filesystem.
+    """
+
+    protocol = "dir"
+
+    def __init__(
+        self,
+        path=None,
+        fs=None,
+        fo=None,
+        target_protocol=None,
+        target_options=None,
+        **storage_options,
+    ):
+        """
+        Parameters
+        ----------
+        path: str
+            Path to the directory.
+        fs: AbstractFileSystem
+            An instantiated filesystem to wrap.
+        target_protocol, target_options:
+            if fs is none, construct it from these
+        fo: str
+            Alternate for path; do not provide both
+        """
+        super().__init__(**storage_options)
+        if fs is None:
+            fs = filesystem(protocol=target_protocol, **(target_options or {}))
+        path = path or fo
+
+        if self.asynchronous and not fs.async_impl:
+            raise ValueError("can't use asynchronous with non-async fs")
+
+        if fs.async_impl and self.asynchronous != fs.asynchronous:
+            raise ValueError("both dirfs and fs should be in the same sync/async mode")
+
+        self.path = fs._strip_protocol(path)
+        self.fs = fs
+
+    def _join(self, path):
+        if isinstance(path, str):
+            if not self.path:
+                return path
+            if not path:
+                return self.path
+            path = self._strip_protocol(path)
+            # ".." only navigates above the root on filesystems that resolve it
+            # against a real directory tree; on object stores it is a literal
+            # path part, so only guard the local case here.
+            if isinstance(self.fs, LocalFileSystem) and _escapes_root(path):
+                raise ValueError(
+                    f"path {path!r} escapes the {self.path!r} root of the filesystem"
+                )
+            return self.fs.sep.join((self.path, path))
+        if isinstance(path, dict):
+            return {self._join(_path): value for _path, value in path.items()}
+        return [self._join(_path) for _path in path]
+
+    def _relpath(self, path):
+        if isinstance(path, str):
+            if not self.path:
+                return path
+            # We need to account for S3FileSystem returning paths that do not
+            # start with a '/'
+            if path == self.path or (
+                self.path.startswith(self.fs.sep) and path == self.path[1:]
+            ):
+                return ""
+            prefix = self.path + self.fs.sep
+            if self.path.startswith(self.fs.sep) and not path.startswith(self.fs.sep):
+                prefix = prefix[1:]
+            assert path.startswith(prefix)
+            return path[len(prefix) :]
+        return [self._relpath(_path) for _path in path]
+
+    def _relpath_detail(self, paths):
+        out = {}
+        for path, info in paths.items():
+            path = self._relpath(path)
+            info = info.copy()
+            info["name"] = path
+            out[path] = info
+        return out
+
+    # Wrappers below
+
+    @property
+    def sep(self):
+        return self.fs.sep
+
+    async def set_session(self, *args, **kwargs):
+        return await self.fs.set_session(*args, **kwargs)
+
+    async def _rm_file(self, path, **kwargs):
+        return await self.fs._rm_file(self._join(path), **kwargs)
+
+    def rm_file(self, path, **kwargs):
+        return self.fs.rm_file(self._join(path), **kwargs)
+
+    async def _rm(self, path, *args, **kwargs):
+        return await self.fs._rm(self._join(path), *args, **kwargs)
+
+    def rm(self, path, *args, **kwargs):
+        return self.fs.rm(self._join(path), *args, **kwargs)
+
+    def delete(self, path, recursive=False, maxdepth=None):
+        return self.fs.delete(self._join(path), recursive=recursive, maxdepth=maxdepth)
+
+    async def _cp_file(self, path1, path2, **kwargs):
+        return await self.fs._cp_file(self._join(path1), self._join(path2), **kwargs)
+
+    def cp_file(self, path1, path2, **kwargs):
+        return self.fs.cp_file(self._join(path1), self._join(path2), **kwargs)
+
+    async def _copy(
+        self,
+        path1,
+        path2,
+        *args,
+        **kwargs,
+    ):
+        return await self.fs._copy(
+            self._join(path1),
+            self._join(path2),
+            *args,
+            **kwargs,
+        )
+
+    def copy(self, path1, path2, *args, **kwargs):
+        return self.fs.copy(
+            self._join(path1),
+            self._join(path2),
+            *args,
+            **kwargs,
+        )
+
+    async def _pipe(self, path, *args, **kwargs):
+        return await self.fs._pipe(self._join(path), *args, **kwargs)
+
+    def pipe(self, path, *args, **kwargs):
+        return self.fs.pipe(self._join(path), *args, **kwargs)
+
+    async def _pipe_file(self, path, *args, **kwargs):
+        return await self.fs._pipe_file(self._join(path), *args, **kwargs)
+
+    def pipe_file(self, path, *args, **kwargs):
+        return self.fs.pipe_file(self._join(path), *args, **kwargs)
+
+    def write_text(
+        self, path, value, encoding=None, errors=None, newline=None, **kwargs
+    ):
+        return self.fs.write_text(
+            self._join(path),
+            value,
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            **kwargs,
+        )
+
+    async def _cat_file(self, path, *args, **kwargs):
+        return await self.fs._cat_file(self._join(path), *args, **kwargs)
+
+    def cat_file(self, path, *args, **kwargs):
+        return self.fs.cat_file(self._join(path), *args, **kwargs)
+
+    async def _cat(self, path, *args, **kwargs):
+        ret = await self.fs._cat(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
+
+        if isinstance(ret, dict):
+            return {self._relpath(key): value for key, value in ret.items()}
+
+        return ret
+
+    def cat(self, path, *args, **kwargs):
+        ret = self.fs.cat(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
+
+        if isinstance(ret, dict):
+            return {self._relpath(key): value for key, value in ret.items()}
+
+        return ret
+
+    async def _cat_ranges(self, paths, starts, ends, *args, **kwargs):
+        return await self.fs._cat_ranges(
+            self._join(paths), starts, ends, *args, **kwargs
+        )
+
+    def cat_ranges(self, paths, starts, ends, *args, **kwargs):
+        return self.fs.cat_ranges(self._join(paths), starts, ends, *args, **kwargs)
+
+    async def _put_file(self, lpath, rpath, **kwargs):
+        return await self.fs._put_file(lpath, self._join(rpath), **kwargs)
+
+    def put_file(self, lpath, rpath, **kwargs):
+        return self.fs.put_file(lpath, self._join(rpath), **kwargs)
+
+    async def _put(
+        self,
+        lpath,
+        rpath,
+        *args,
+        **kwargs,
+    ):
+        return await self.fs._put(
+            lpath,
+            self._join(rpath),
+            *args,
+            **kwargs,
+        )
+
+    def put(self, lpath, rpath, *args, **kwargs):
+        return self.fs.put(
+            lpath,
+            self._join(rpath),
+            *args,
+            **kwargs,
+        )
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        return await self.fs._get_file(self._join(rpath), lpath, **kwargs)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        return self.fs.get_file(self._join(rpath), lpath, **kwargs)
+
+    async def _get(self, rpath, *args, **kwargs):
+        return await self.fs._get(self._join(rpath), *args, **kwargs)
+
+    def get(self, rpath, *args, **kwargs):
+        return self.fs.get(self._join(rpath), *args, **kwargs)
+
+    async def _isfile(self, path):
+        return await self.fs._isfile(self._join(path))
+
+    def isfile(self, path):
+        return self.fs.isfile(self._join(path))
+
+    async def _isdir(self, path):
+        return await self.fs._isdir(self._join(path))
+
+    def isdir(self, path):
+        return self.fs.isdir(self._join(path))
+
+    async def _size(self, path):
+        return await self.fs._size(self._join(path))
+
+    def size(self, path):
+        return self.fs.size(self._join(path))
+
+    async def _sizes(self, paths):
+        return await self.fs._sizes(self._join(paths))
+
+    def sizes(self, paths):
+        return self.fs.sizes(self._join(paths))
+
+    def invalidate_cache(self, path=None):
+        # With no path, clear only what is cached under this directory. An
+        # unrooted dirfs joins to "", which means everything on the wrapped fs.
+        self.fs.invalidate_cache(self._join(path or "") or None)
+
+    def ukey(self, path):
+        return self.fs.ukey(self._join(path))
+
+    def checksum(self, path):
+        return self.fs.checksum(self._join(path))
+
+    async def _exists(self, path):
+        return await self.fs._exists(self._join(path))
+
+    def exists(self, path):
+        return self.fs.exists(self._join(path))
+
+    async def _info(self, path, **kwargs):
+        info = await self.fs._info(self._join(path), **kwargs)
+        info = info.copy()
+        info["name"] = self._relpath(info["name"])
+        return info
+
+    def info(self, path, **kwargs):
+        info = self.fs.info(self._join(path), **kwargs)
+        info = info.copy()
+        info["name"] = self._relpath(info["name"])
+        return info
+
+    async def _ls(self, path, detail=True, **kwargs):
+        ret = (await self.fs._ls(self._join(path), detail=detail, **kwargs)).copy()
+        if detail:
+            out = []
+            for entry in ret:
+                entry = entry.copy()
+                entry["name"] = self._relpath(entry["name"])
+                out.append(entry)
+            return out
+
+        return self._relpath(ret)
+
+    def ls(self, path, detail=True, **kwargs):
+        ret = self.fs.ls(self._join(path), detail=detail, **kwargs).copy()
+        if detail:
+            out = []
+            for entry in ret:
+                entry = entry.copy()
+                entry["name"] = self._relpath(entry["name"])
+                out.append(entry)
+            return out
+
+        return self._relpath(ret)
+
+    def _relpath_walk_entries(self, entries):
+        # with detail=True, walk gives dicts keyed by basename whose infos
+        # still carry the full name in the wrapped filesystem
+        if not isinstance(entries, dict):
+            return entries
+        return {
+            name: {**info, "name": self._relpath(info["name"])}
+            for name, info in entries.items()
+        }
+
+    async def _walk(self, path, *args, **kwargs):
+        async for root, dirs, files in self.fs._walk(self._join(path), *args, **kwargs):
+            yield (
+                self._relpath(root),
+                self._relpath_walk_entries(dirs),
+                self._relpath_walk_entries(files),
+            )
+
+    def walk(self, path, *args, **kwargs):
+        for root, dirs, files in self.fs.walk(self._join(path), *args, **kwargs):
+            yield (
+                self._relpath(root),
+                self._relpath_walk_entries(dirs),
+                self._relpath_walk_entries(files),
+            )
+
+    async def _glob(self, path, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = await self.fs._glob(self._join(path), **kwargs)
+        if detail:
+            return self._relpath_detail(ret)
+        return self._relpath(ret)
+
+    def glob(self, path, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = self.fs.glob(self._join(path), **kwargs)
+        if detail:
+            return self._relpath_detail(ret)
+        return self._relpath(ret)
+
+    async def _du(self, path, *args, **kwargs):
+        total = kwargs.get("total", True)
+        ret = await self.fs._du(self._join(path), *args, **kwargs)
+        if total:
+            return ret
+
+        return {self._relpath(path): size for path, size in ret.items()}
+
+    def du(self, path, *args, **kwargs):
+        total = kwargs.get("total", True)
+        ret = self.fs.du(self._join(path), *args, **kwargs)
+        if total:
+            return ret
+
+        return {self._relpath(path): size for path, size in ret.items()}
+
+    async def _find(self, path, *args, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = await self.fs._find(self._join(path), *args, **kwargs)
+        if detail:
+            return self._relpath_detail(ret)
+        return self._relpath(ret)
+
+    def find(self, path, *args, **kwargs):
+        detail = kwargs.get("detail", False)
+        ret = self.fs.find(self._join(path), *args, **kwargs)
+        if detail:
+            return self._relpath_detail(ret)
+        return self._relpath(ret)
+
+    async def _expand_path(self, path, *args, **kwargs):
+        return self._relpath(
+            await self.fs._expand_path(self._join(path), *args, **kwargs)
+        )
+
+    def expand_path(self, path, *args, **kwargs):
+        return self._relpath(self.fs.expand_path(self._join(path), *args, **kwargs))
+
+    async def _mkdir(self, path, *args, **kwargs):
+        return await self.fs._mkdir(self._join(path), *args, **kwargs)
+
+    def mkdir(self, path, *args, **kwargs):
+        return self.fs.mkdir(self._join(path), *args, **kwargs)
+
+    async def _makedirs(self, path, *args, **kwargs):
+        return await self.fs._makedirs(self._join(path), *args, **kwargs)
+
+    def makedirs(self, path, *args, **kwargs):
+        return self.fs.makedirs(self._join(path), *args, **kwargs)
+
+    def rmdir(self, path):
+        return self.fs.rmdir(self._join(path))
+
+    def mv(self, path1, path2, **kwargs):
+        return self.fs.mv(
+            self._join(path1),
+            self._join(path2),
+            **kwargs,
+        )
+
+    def touch(self, path, **kwargs):
+        return self.fs.touch(self._join(path), **kwargs)
+
+    def created(self, path):
+        return self.fs.created(self._join(path))
+
+    def modified(self, path):
+        return self.fs.modified(self._join(path))
+
+    def sign(self, path, *args, **kwargs):
+        return self.fs.sign(self._join(path), *args, **kwargs)
+
+    def __repr__(self):
+        return f"{self.__class__.__qualname__}(path='{self.path}', fs={self.fs})"
+
+    def open(
+        self,
+        path,
+        *args,
+        **kwargs,
+    ):
+        return self.fs.open(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
+
+    async def open_async(
+        self,
+        path,
+        *args,
+        **kwargs,
+    ):
+        return await self.fs.open_async(
+            self._join(path),
+            *args,
+            **kwargs,
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/ftp.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/ftp.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f20d4302c460e2460c6ab1bd99b07904fc765cb
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/ftp.py
@@ -0,0 +1,442 @@
+import os
+import ssl
+import uuid
+from ftplib import FTP, FTP_TLS, Error, error_perm
+from typing import Any
+
+from ..spec import AbstractBufferedFile, AbstractFileSystem
+from ..utils import infer_storage_options, isfilelike
+
+SECURITY_PROTOCOL_MAP = {
+    "tls": ssl.PROTOCOL_TLS,
+    "sslv23": ssl.PROTOCOL_SSLv23,
+}
+for protocol in ["TLSv1", "TLSv1_1", "TLSv1_2"]:
+    if hasattr(ssl, f"PROTOCOL_{protocol}"):
+        SECURITY_PROTOCOL_MAP[protocol.lower()] = getattr(ssl, f"PROTOCOL_{protocol}")
+
+
+class ImplicitFTPTLS(FTP_TLS):
+    """
+    FTP_TLS subclass that automatically wraps sockets in SSL
+    to support implicit FTPS.
+    """
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._sock = None
+
+    @property
+    def sock(self):
+        """Return the socket."""
+        return self._sock
+
+    @sock.setter
+    def sock(self, value):
+        """When modifying the socket, ensure that it is ssl wrapped."""
+        if value is not None and not isinstance(value, ssl.SSLSocket):
+            value = self.context.wrap_socket(value)
+        self._sock = value
+
+
+class FTPFileSystem(AbstractFileSystem):
+    """A filesystem over classic FTP"""
+
+    root_marker = "/"
+    cachable = False
+    protocol = "ftp"
+
+    def __init__(
+        self,
+        host,
+        port=21,
+        username=None,
+        password=None,
+        acct=None,
+        block_size=None,
+        tempdir=None,
+        timeout=30,
+        encoding="utf-8",
+        tls=False,
+        **kwargs,
+    ):
+        """
+        You can use _get_kwargs_from_urls to get some kwargs from
+        a reasonable FTP url.
+
+        Authentication will be anonymous if username/password are not
+        given.
+
+        Parameters
+        ----------
+        host: str
+            The remote server name/ip to connect to
+        port: int
+            Port to connect with
+        username: str or None
+            If authenticating, the user's identifier
+        password: str of None
+            User's password on the server, if using
+        acct: str or None
+            Some servers also need an "account" string for auth
+        block_size: int or None
+            If given, the read-ahead or write buffer size.
+        tempdir: str
+            Directory on remote to put temporary files when in a transaction
+        timeout: int
+            Timeout of the ftp connection in seconds
+        encoding: str
+            Encoding to use for directories and filenames in FTP connection
+        tls: bool or str
+            Enable FTP-TLS for secure connections:
+                - False: Plain FTP (default)
+                - True: Explicit TLS (FTPS with AUTH TLS command)
+                - "tls": Auto-negotiate highest protocol
+                - "tlsv1": TLS v1.0
+                - "tlsv1_1": TLS v1.1
+                - "tlsv1_2": TLS v1.2
+        """
+        super().__init__(**kwargs)
+        self.host = host
+        self.port = port
+        self.tempdir = tempdir or "/tmp"
+        self.cred = username or "", password or "", acct or ""
+        self.timeout = timeout
+        self.encoding = encoding
+        if block_size is not None:
+            self.blocksize = block_size
+        else:
+            self.blocksize = 2**16
+        self.tls = tls
+        self._connect()
+        if isinstance(self.tls, bool) and self.tls:
+            self.ftp.prot_p()
+
+    def _connect(self):
+        security = None
+        if self.tls:
+            if isinstance(self.tls, str):
+                ftp_cls = ImplicitFTPTLS
+                security = SECURITY_PROTOCOL_MAP.get(
+                    self.tls,
+                    f"Not supported {self.tls} protocol",
+                )
+                if isinstance(security, str):
+                    raise ValueError(security)
+            else:
+                ftp_cls = FTP_TLS
+        else:
+            ftp_cls = FTP
+        self.ftp = ftp_cls(timeout=self.timeout, encoding=self.encoding)
+        if security:
+            self.ftp.ssl_version = security
+        self.ftp.connect(self.host, self.port)
+        self.ftp.login(*self.cred)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return "/" + infer_storage_options(path)["path"].lstrip("/").rstrip("/")
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        out = []
+        if path not in self.dircache:
+            try:
+                try:
+                    out = [
+                        (fn, details)
+                        for (fn, details) in self.ftp.mlsd(path)
+                        if fn not in [".", ".."]
+                        and details["type"] not in ["pdir", "cdir"]
+                    ]
+                except error_perm:
+                    out = _mlsd2(self.ftp, path)  # Not platform independent
+                for fn, details in out:
+                    details["name"] = "/".join(
+                        ["" if path == "/" else path, fn.lstrip("/")]
+                    )
+                    if details["type"] == "file":
+                        details["size"] = int(details["size"])
+                    else:
+                        details["size"] = 0
+                    if details["type"] == "dir":
+                        details["type"] = "directory"
+                self.dircache[path] = out
+            except Error:
+                try:
+                    info = self.info(path)
+                    if info["type"] == "file":
+                        out = [(path, info)]
+                except (Error, IndexError) as exc:
+                    raise FileNotFoundError(path) from exc
+        files = self.dircache.get(path, out)
+        if not detail:
+            return sorted([fn for fn, details in files])
+        return [details for fn, details in files]
+
+    def info(self, path, **kwargs):
+        # implement with direct method
+        path = self._strip_protocol(path)
+        if path == "/":
+            # special case, since this dir has no real entry
+            return {"name": "/", "size": 0, "type": "directory"}
+        files = self.ls(self._parent(path).lstrip("/"), True)
+        try:
+            out = next(f for f in files if f["name"] == path)
+        except StopIteration as exc:
+            raise FileNotFoundError(path) from exc
+        return out
+
+    def get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            if not os.path.exists(lpath):
+                os.mkdir(lpath)
+            return
+        if isfilelike(lpath):
+            outfile = lpath
+        else:
+            outfile = open(lpath, "wb")
+
+        def cb(x):
+            outfile.write(x)
+
+        self.ftp.retrbinary(
+            f"RETR {rpath}",
+            blocksize=self.blocksize,
+            callback=cb,
+        )
+        if not isfilelike(lpath):
+            outfile.close()
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        if end is not None:
+            return super().cat_file(path, start, end, **kwargs)
+        out = []
+
+        def cb(x):
+            out.append(x)
+
+        try:
+            self.ftp.retrbinary(
+                f"RETR {path}",
+                blocksize=self.blocksize,
+                rest=start,
+                callback=cb,
+            )
+        except (Error, error_perm) as orig_exc:
+            raise FileNotFoundError(path) from orig_exc
+        return b"".join(out)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        cache_options=None,
+        autocommit=True,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        block_size = block_size or self.blocksize
+        return FTPFile(
+            self,
+            path,
+            mode=mode,
+            block_size=block_size,
+            tempdir=self.tempdir,
+            autocommit=autocommit,
+            cache_options=cache_options,
+        )
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        self.ftp.delete(path)
+        self.invalidate_cache(self._parent(path))
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(paths):
+            if self.isfile(p):
+                self.rm_file(p)
+            else:
+                self.rmdir(p)
+
+    def mkdir(self, path: str, create_parents: bool = True, **kwargs: Any) -> None:
+        path = self._strip_protocol(path)
+        parent = self._parent(path)
+        if parent != self.root_marker and not self.exists(parent) and create_parents:
+            self.mkdir(parent, create_parents=create_parents)
+
+        self.ftp.mkd(path)
+        self.invalidate_cache(self._parent(path))
+
+    def makedirs(self, path: str, exist_ok: bool = False) -> None:
+        path = self._strip_protocol(path)
+        if self.exists(path):
+            # NB: "/" does not "exist" as it has no directory entry
+            if not exist_ok:
+                raise FileExistsError(f"{path} exists without `exist_ok`")
+            # exists_ok=True -> no-op
+        else:
+            self.mkdir(path, create_parents=True)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        self.ftp.rmd(path)
+        self.invalidate_cache(self._parent(path))
+
+    def mv(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+        self.ftp.rename(path1, path2)
+        self.invalidate_cache(self._parent(path1))
+        self.invalidate_cache(self._parent(path2))
+
+    def __del__(self):
+        self.ftp.close()
+
+    def invalidate_cache(self, path=None):
+        if path is None:
+            self.dircache.clear()
+        else:
+            self.dircache.pop(path, None)
+        super().invalidate_cache(path)
+
+
+class TransferDone(Exception):
+    """Internal exception to break out of transfer"""
+
+    pass
+
+
+class FTPFile(AbstractBufferedFile):
+    """Interact with a remote FTP file with read/write buffering"""
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        **kwargs,
+    ):
+        super().__init__(
+            fs,
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+        if not autocommit:
+            self.target = self.path
+            self.path = "/".join([kwargs["tempdir"], str(uuid.uuid4())])
+
+    def commit(self):
+        self.fs.mv(self.path, self.target)
+
+    def discard(self):
+        self.fs.rm(self.path)
+
+    def _fetch_range(self, start, end):
+        """Get bytes between given byte limits
+
+        Implemented by raising an exception in the fetch callback when the
+        number of bytes received reaches the requested amount.
+
+        Will fail if the server does not respect the REST command on
+        retrieve requests.
+        """
+        out = []
+        total = [0]
+
+        def callback(x):
+            total[0] += len(x)
+            if total[0] > end - start:
+                out.append(x[: (end - start) - total[0]])
+                if end < self.size:
+                    raise TransferDone
+            else:
+                out.append(x)
+
+            if total[0] == end - start and end < self.size:
+                raise TransferDone
+
+        try:
+            self.fs.ftp.retrbinary(
+                f"RETR {self.path}",
+                blocksize=self.blocksize,
+                rest=start,
+                callback=callback,
+            )
+        except TransferDone:
+            try:
+                # stop transfer, we got enough bytes for this block
+                self.fs.ftp.abort()
+                self.fs.ftp.getmultiline()
+            except Error:
+                self.fs._connect()
+
+        return b"".join(out)
+
+    def _upload_chunk(self, final=False):
+        self.buffer.seek(0)
+        self.fs.ftp.storbinary(
+            f"STOR {self.path}", self.buffer, blocksize=self.blocksize, rest=self.offset
+        )
+        return True
+
+
+def _mlsd2(ftp, path="."):
+    """
+    Fall back to using `dir` instead of `mlsd` if not supported.
+
+    This parses a Linux style `ls -l` response to `dir`, but the response may
+    be platform dependent.
+
+    Parameters
+    ----------
+    ftp: ftplib.FTP
+    path: str
+        Expects to be given path, but defaults to ".".
+    """
+    lines = []
+    minfo = []
+    ftp.dir(path, lines.append)
+    for line in lines:
+        split_line = line.split(maxsplit=8)
+        if len(split_line) < 9:
+            continue
+        name = split_line[8]
+        unix_mode = split_line[0]
+        if unix_mode[0] == "l" and " -> " in name:
+            # Symbolic link: "<name> -> <target>"; keep only the link name.
+            name = name.split(" -> ", 1)[0]
+        this = (
+            name,
+            {
+                "modify": " ".join(split_line[5:8]),
+                "unix.owner": split_line[2],
+                "unix.group": split_line[3],
+                "unix.mode": unix_mode,
+                "size": split_line[4],
+            },
+        )
+        if this[1]["unix.mode"][0] == "d":
+            this[1]["type"] = "dir"
+        else:
+            this[1]["type"] = "file"
+        minfo.append(this)
+    return minfo
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/gist.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/gist.py
new file mode 100644
index 0000000000000000000000000000000000000000..ad9ac0b6a1cdbcfba6188e2cdeab2350bb9aad0a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/gist.py
@@ -0,0 +1,241 @@
+import requests
+
+from ..spec import AbstractFileSystem
+from ..utils import infer_storage_options
+from .memory import MemoryFile
+
+
+class GistFileSystem(AbstractFileSystem):
+    """
+    Interface to files in a single GitHub Gist.
+
+    Provides read-only access to a gist's files. Gists do not contain
+    subdirectories, so file listing is straightforward.
+
+    Parameters
+    ----------
+    gist_id: str
+        The ID of the gist you want to access (the long hex value from the URL).
+    filenames: list[str] (optional)
+        If provided, only make a file system representing these files, and do not fetch
+        the list of all files for this gist.
+    sha: str (optional)
+        If provided, fetch a particular revision of the gist. If omitted,
+        the latest revision is used.
+    username: str (optional)
+        GitHub username for authentication.
+    token: str (optional)
+        GitHub personal access token (required if username is given), or.
+    timeout: (float, float) or float, optional
+        Connect and read timeouts for requests (default 60s each).
+    kwargs: dict
+        Stored on `self.request_kw` and passed to `requests.get` when fetching Gist
+        metadata or reading ("opening") a file.
+    """
+
+    protocol = "gist"
+    gist_url = "https://api.github.com/gists/{gist_id}"
+    gist_rev_url = "https://api.github.com/gists/{gist_id}/{sha}"
+
+    def __init__(
+        self,
+        gist_id,
+        filenames=None,
+        sha=None,
+        username=None,
+        token=None,
+        timeout=None,
+        **kwargs,
+    ):
+        super().__init__()
+        self.gist_id = gist_id
+        self.filenames = filenames
+        self.sha = sha  # revision of the gist (optional)
+        if username is not None and token is None:
+            raise ValueError("User auth requires a token")
+        self.username = username
+        self.token = token
+        self.request_kw = kwargs
+        # Default timeouts to 60s connect/read if none provided
+        self.timeout = timeout if timeout is not None else (60, 60)
+
+        # We use a single-level "directory" cache, because a gist is essentially flat
+        self.dircache[""] = self._fetch_file_list()
+
+    @property
+    def kw(self):
+        """Auth parameters passed to 'requests' if we have username/token."""
+        kw = {
+            "headers": {
+                "Accept": "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            }
+        }
+        kw.update(self.request_kw)
+        if self.username and self.token:
+            kw["auth"] = (self.username, self.token)
+        elif self.token:
+            kw["headers"]["Authorization"] = f"Bearer {self.token}"
+        return kw
+
+    def _fetch_gist_metadata(self):
+        """
+        Fetch the JSON metadata for this gist (possibly for a specific revision).
+        """
+        if self.sha:
+            url = self.gist_rev_url.format(gist_id=self.gist_id, sha=self.sha)
+        else:
+            url = self.gist_url.format(gist_id=self.gist_id)
+
+        r = requests.get(url, timeout=self.timeout, **self.kw)
+        if r.status_code == 404:
+            raise FileNotFoundError(
+                f"Gist not found: {self.gist_id}@{self.sha or 'latest'}"
+            )
+        r.raise_for_status()
+        return r.json()
+
+    def _fetch_file_list(self):
+        """
+        Returns a list of dicts describing each file in the gist. These get stored
+        in self.dircache[""].
+        """
+        meta = self._fetch_gist_metadata()
+        if self.filenames:
+            available_files = meta.get("files", {})
+            files = {}
+            for fn in self.filenames:
+                if fn not in available_files:
+                    raise FileNotFoundError(fn)
+                files[fn] = available_files[fn]
+        else:
+            files = meta.get("files", {})
+
+        out = []
+        for fname, finfo in files.items():
+            if finfo is None:
+                # Occasionally GitHub returns a file entry with null if it was deleted
+                continue
+            # Build a directory entry
+            out.append(
+                {
+                    "name": fname,  # file's name
+                    "type": "file",  # gists have no subdirectories
+                    "size": finfo.get("size", 0),  # file size in bytes
+                    "raw_url": finfo.get("raw_url"),
+                }
+            )
+        return out
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        """
+        Remove 'gist://' from the path, if present.
+        """
+        # The default infer_storage_options can handle gist://username:token@id/file
+        # or gist://id/file, but let's ensure we handle a normal usage too.
+        # We'll just strip the protocol prefix if it exists.
+        path = infer_storage_options(path).get("path", path)
+        return path.lstrip("/")
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        """
+        Parse 'gist://' style URLs into GistFileSystem constructor kwargs.
+        For example:
+          gist://:TOKEN@<gist_id>/file.txt
+          gist://username:TOKEN@<gist_id>/file.txt
+        """
+        so = infer_storage_options(path)
+        out = {}
+        if "username" in so and so["username"]:
+            out["username"] = so["username"]
+        if "password" in so and so["password"]:
+            out["token"] = so["password"]
+        if "host" in so and so["host"]:
+            # We interpret 'host' as the gist ID
+            out["gist_id"] = so["host"]
+
+        # Extract SHA and filename from path
+        if "path" in so and so["path"]:
+            path_parts = so["path"].rsplit("/", 2)[-2:]
+            if len(path_parts) == 2:
+                if path_parts[0]:  # SHA present
+                    out["sha"] = path_parts[0]
+                if path_parts[1]:  # filename also present
+                    out["filenames"] = [path_parts[1]]
+
+        return out
+
+    def ls(self, path="", detail=False, **kwargs):
+        """
+        List files in the gist. Gists are single-level, so any 'path' is basically
+        the filename, or empty for all files.
+
+        Parameters
+        ----------
+        path : str, optional
+            The filename to list. If empty, returns all files in the gist.
+        detail : bool, default False
+            If True, return a list of dicts; if False, return a list of filenames.
+        """
+        path = self._strip_protocol(path or "")
+        # If path is empty, return all
+        if path == "":
+            results = self.dircache[""]
+        else:
+            # We want just the single file with this name
+            all_files = self.dircache[""]
+            results = [f for f in all_files if f["name"] == path]
+            if not results:
+                raise FileNotFoundError(path)
+        if detail:
+            return results
+        else:
+            return sorted(f["name"] for f in results)
+
+    def _open(self, path, mode="rb", block_size=None, **kwargs):
+        """
+        Read a single file from the gist.
+        """
+        if mode != "rb":
+            raise NotImplementedError("GitHub Gist FS is read-only (no write).")
+
+        path = self._strip_protocol(path)
+        # Find the file entry in our dircache
+        matches = [f for f in self.dircache[""] if f["name"] == path]
+        if not matches:
+            raise FileNotFoundError(path)
+        finfo = matches[0]
+
+        raw_url = finfo.get("raw_url")
+        if not raw_url:
+            raise FileNotFoundError(f"No raw_url for file: {path}")
+
+        r = requests.get(raw_url, timeout=self.timeout, **self.kw)
+        if r.status_code == 404:
+            raise FileNotFoundError(path)
+        r.raise_for_status()
+        return MemoryFile(path, None, r.content)
+
+    def cat(self, path, recursive=False, on_error="raise", **kwargs):
+        """
+        Return {path: contents} for the given file or files. If 'recursive' is True,
+        and path is empty, returns all files in the gist.
+        """
+        paths = self.expand_path(path, recursive=recursive)
+        out = {}
+        for p in paths:
+            try:
+                with self.open(p, "rb") as f:
+                    out[p] = f.read()
+            except FileNotFoundError as e:
+                if on_error == "raise":
+                    raise e
+                elif on_error == "omit":
+                    pass  # skip
+                else:
+                    out[p] = e
+        if len(paths) == 1 and paths[0] == path:
+            return out[path]
+        return out
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/git.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/git.py
new file mode 100644
index 0000000000000000000000000000000000000000..808d293a1c991ea87d19a2129f3e56d9b813daaa
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/git.py
@@ -0,0 +1,114 @@
+import os
+
+import pygit2
+
+from fsspec.spec import AbstractFileSystem
+
+from .memory import MemoryFile
+
+
+class GitFileSystem(AbstractFileSystem):
+    """Browse the files of a local git repo at any hash/tag/branch
+
+    (experimental backend)
+    """
+
+    root_marker = ""
+    cachable = True
+
+    def __init__(self, path=None, fo=None, ref=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        path: str (optional)
+            Local location of the repo (uses current directory if not given).
+            May be deprecated in favour of ``fo``. When used with a higher
+            level function such as fsspec.open(), may be of the form
+            "git://[path-to-repo[:]][ref@]path/to/file" (but the actual
+            file path should not contain "@" or ":").
+        fo: str (optional)
+            Same as ``path``, but passed as part of a chained URL. This one
+            takes precedence if both are given.
+        ref: str (optional)
+            Reference to work with, could be a hash, tag or branch name. Defaults
+            to current working tree. Note that ``ls`` and ``open`` also take hash,
+            so this becomes the default for those operations
+        kwargs
+        """
+        super().__init__(**kwargs)
+        self.repo = pygit2.Repository(fo or path or os.getcwd())
+        self.ref = ref or "master"
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        path = super()._strip_protocol(path).lstrip("/")
+        if ":" in path:
+            path = path.split(":", 1)[1]
+        if "@" in path:
+            path = path.split("@", 1)[1]
+        return path.lstrip("/")
+
+    def _path_to_object(self, path, ref):
+        comm, ref = self.repo.resolve_refish(ref or self.ref)
+        parts = path.split("/")
+        tree = comm.tree
+        for part in parts:
+            if part and isinstance(tree, pygit2.Tree):
+                if part not in tree:
+                    raise FileNotFoundError(path)
+                tree = tree[part]
+        return tree
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        path = path.removeprefix("git://")
+        out = {}
+        if ":" in path:
+            out["path"], path = path.split(":", 1)
+        if "@" in path:
+            out["ref"], path = path.split("@", 1)
+        return out
+
+    @staticmethod
+    def _object_to_info(obj, path=None):
+        # obj.name and obj.filemode are None for the root tree!
+        is_dir = isinstance(obj, pygit2.Tree)
+        return {
+            "type": "directory" if is_dir else "file",
+            "name": (
+                "/".join([path, obj.name or ""]).lstrip("/") if path else obj.name
+            ),
+            "hex": str(obj.id),
+            "mode": "100644" if obj.filemode is None else f"{obj.filemode:o}",
+            "size": 0 if is_dir else obj.size,
+        }
+
+    def ls(self, path, detail=True, ref=None, **kwargs):
+        tree = self._path_to_object(self._strip_protocol(path), ref)
+        return [
+            GitFileSystem._object_to_info(obj, path)
+            if detail
+            else GitFileSystem._object_to_info(obj, path)["name"]
+            for obj in (tree if isinstance(tree, pygit2.Tree) else [tree])
+        ]
+
+    def info(self, path, ref=None, **kwargs):
+        tree = self._path_to_object(self._strip_protocol(path), ref)
+        return GitFileSystem._object_to_info(tree, path)
+
+    def ukey(self, path, ref=None):
+        return self.info(path, ref=ref)["hex"]
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        ref=None,
+        **kwargs,
+    ):
+        obj = self._path_to_object(path, ref or self.ref)
+        return MemoryFile(data=obj.data)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/github.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/github.py
new file mode 100644
index 0000000000000000000000000000000000000000..3630f6db54413e2c396f6cc1b6b10cd379200043
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/github.py
@@ -0,0 +1,333 @@
+import base64
+import re
+
+import requests
+
+from ..spec import AbstractFileSystem
+from ..utils import infer_storage_options
+from .memory import MemoryFile
+
+
+class GithubFileSystem(AbstractFileSystem):
+    """Interface to files in github
+
+    An instance of this class provides the files residing within a remote github
+    repository. You may specify a point in the repos history, by SHA, branch
+    or tag (default is current master).
+
+    For files less than 1 MB in size, file content is returned directly in a
+    MemoryFile. For larger files, or for files tracked by git-lfs, file content
+    is returned as an HTTPFile wrapping the ``download_url`` provided by the
+    GitHub API.
+
+    When using fsspec.open, allows URIs of the form:
+
+    - "github://path/file", in which case you must specify org, repo and
+      may specify sha in the extra args
+    - 'github://org:repo@/precip/catalog.yml', where the org and repo are
+      part of the URI
+    - 'github://org:repo@sha/precip/catalog.yml', where the sha is also included
+
+    ``sha`` can be the full or abbreviated hex of the commit you want to fetch
+    from, or a branch or tag name (so long as it doesn't contain special characters
+    like "/", "?", which would have to be HTTP-encoded).
+
+    For authorised access, you must provide username and token, which can be made
+    at https://github.com/settings/tokens
+    """
+
+    url = "https://api.github.com/repos/{org}/{repo}/git/trees/{sha}"
+    content_url = "https://api.github.com/repos/{org}/{repo}/contents/{path}?ref={sha}"
+    protocol = "github"
+    timeout = (60, 60)  # connect, read timeouts
+
+    def __init__(
+        self, org, repo, sha=None, username=None, token=None, timeout=None, **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.org = org
+        self.repo = repo
+        if (username is None) ^ (token is None):
+            raise ValueError("Auth required both username and token")
+        self.username = username
+        self.token = token
+        if timeout is not None:
+            self.timeout = timeout
+        if sha is None:
+            # look up default branch (not necessarily "master")
+            u = "https://api.github.com/repos/{org}/{repo}"
+            r = requests.get(
+                u.format(org=org, repo=repo), timeout=self.timeout, **self.kw
+            )
+            r.raise_for_status()
+            sha = r.json()["default_branch"]
+
+        self.root = sha
+        self.ls("")
+        try:
+            from .http import HTTPFileSystem
+
+            self.http_fs = HTTPFileSystem(**kwargs)
+        except ImportError:
+            self.http_fs = None
+
+    @property
+    def kw(self):
+        if self.username:
+            return {"auth": (self.username, self.token)}
+        return {}
+
+    @classmethod
+    def repos(cls, org_or_user, is_org=True):
+        """List repo names for given org or user
+
+        This may become the top level of the FS
+
+        Parameters
+        ----------
+        org_or_user: str
+            Name of the github org or user to query
+        is_org: bool (default True)
+            Whether the name is an organisation (True) or user (False)
+
+        Returns
+        -------
+        List of string
+        """
+        r = requests.get(
+            f"https://api.github.com/{['users', 'orgs'][is_org]}/{org_or_user}/repos",
+            timeout=cls.timeout,
+        )
+        r.raise_for_status()
+        return [repo["name"] for repo in r.json()]
+
+    @property
+    def tags(self):
+        """Names of tags in the repo"""
+        r = requests.get(
+            f"https://api.github.com/repos/{self.org}/{self.repo}/tags",
+            timeout=self.timeout,
+            **self.kw,
+        )
+        r.raise_for_status()
+        return [t["name"] for t in r.json()]
+
+    @property
+    def branches(self):
+        """Names of branches in the repo"""
+        r = requests.get(
+            f"https://api.github.com/repos/{self.org}/{self.repo}/branches",
+            timeout=self.timeout,
+            **self.kw,
+        )
+        r.raise_for_status()
+        return [t["name"] for t in r.json()]
+
+    @property
+    def refs(self):
+        """Named references, tags and branches"""
+        return {"tags": self.tags, "branches": self.branches}
+
+    def ls(self, path, detail=False, sha=None, _sha=None, **kwargs):
+        """List files at given path
+
+        Parameters
+        ----------
+        path: str
+            Location to list, relative to repo root
+        detail: bool
+            If True, returns list of dicts, one per file; if False, returns
+            list of full filenames only
+        sha: str (optional)
+            List at the given point in the repo history, branch or tag name or commit
+            SHA
+        _sha: str (optional)
+            List this specific tree object (used internally to descend into trees)
+        """
+        path = self._strip_protocol(path)
+        if path == "":
+            _sha = sha or self.root
+        if _sha is None:
+            parts = path.rstrip("/").split("/")
+            so_far = ""
+            _sha = sha or self.root
+            for part in parts:
+                out = self.ls(so_far, True, sha=sha, _sha=_sha)
+                so_far += "/" + part if so_far else part
+                out = [o for o in out if o["name"] == so_far]
+                if not out:
+                    raise FileNotFoundError(path)
+                out = out[0]
+                if out["type"] == "file":
+                    if detail:
+                        return [out]
+                    else:
+                        return path
+                _sha = out["sha"]
+        if path not in self.dircache or sha not in [self.root, None]:
+            r = requests.get(
+                self.url.format(org=self.org, repo=self.repo, sha=_sha),
+                timeout=self.timeout,
+                **self.kw,
+            )
+            if r.status_code == 404:
+                raise FileNotFoundError(path)
+            r.raise_for_status()
+            types = {"blob": "file", "tree": "directory"}
+            out = [
+                {
+                    "name": path + "/" + f["path"] if path else f["path"],
+                    "mode": f["mode"],
+                    "type": types[f["type"]],
+                    "size": f.get("size", 0),
+                    "sha": f["sha"],
+                }
+                for f in r.json()["tree"]
+                if f["type"] in types
+            ]
+            if sha in [self.root, None]:
+                self.dircache[path] = out
+        else:
+            out = self.dircache[path]
+        if detail:
+            return out
+        else:
+            return sorted([f["name"] for f in out])
+
+    def invalidate_cache(self, path=None):
+        self.dircache.clear()
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        opts = infer_storage_options(path)
+        if "username" not in opts:
+            return super()._strip_protocol(path)
+        return opts["path"].lstrip("/")
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        opts = infer_storage_options(path)
+        if "username" not in opts:
+            return {}
+        out = {"org": opts["username"], "repo": opts["password"]}
+        if opts["host"]:
+            out["sha"] = opts["host"]
+        return out
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        cache_options=None,
+        sha=None,
+        **kwargs,
+    ):
+        if mode != "rb":
+            raise NotImplementedError
+
+        # construct a url to hit the GitHub API's repo contents API
+        url = self.content_url.format(
+            org=self.org, repo=self.repo, path=path, sha=sha or self.root
+        )
+
+        # make a request to this API, and parse the response as JSON
+        r = requests.get(url, timeout=self.timeout, **self.kw)
+        if r.status_code == 404:
+            raise FileNotFoundError(path)
+        r.raise_for_status()
+        content_json = r.json()
+
+        # if the response's content key is not empty, try to parse it as base64
+        if content_json["content"]:
+            content = base64.b64decode(content_json["content"])
+
+            # as long as the content does not start with the string
+            # "version https://git-lfs.github.com/"
+            # then it is probably not a git-lfs pointer and we can just return
+            # the content directly
+            if not content.startswith(b"version https://git-lfs.github.com/"):
+                return MemoryFile(None, None, content)
+
+        # we land here if the content was not present in the first response
+        # (regular file over 1MB or git-lfs tracked file)
+        # in this case, we get let the HTTPFileSystem handle the download
+        if self.http_fs is None:
+            raise ImportError(
+                "Please install fsspec[http] to access github files >1 MB "
+                "or git-lfs tracked files."
+            )
+        return self.http_fs.open(
+            content_json["download_url"],
+            mode=mode,
+            block_size=block_size,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def rm(self, path, recursive=False, maxdepth=None, message=None):
+        path = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(path):
+            self.rm_file(p, message=message)
+
+    def rm_file(self, path, message=None, **kwargs):
+        """
+        Remove a file from a specified branch using a given commit message.
+
+        Since Github DELETE operation requires a branch name, and we can't reliably
+        determine whether the provided SHA refers to a branch, tag, or commit, we
+        assume it's a branch. If it's not, the user will encounter an error when
+        attempting to retrieve the file SHA or delete the file.
+
+        Parameters
+        ----------
+        path: str
+            The file's location relative to the repository root.
+        message: str, optional
+            The commit message for the deletion.
+        """
+
+        if not self.username:
+            raise ValueError("Authentication required")
+
+        path = self._strip_protocol(path)
+
+        # Attempt to get SHA from cache or Github API
+        sha = self._get_sha_from_cache(path)
+        if not sha:
+            url = self.content_url.format(
+                org=self.org, repo=self.repo, path=path.lstrip("/"), sha=self.root
+            )
+            r = requests.get(url, timeout=self.timeout, **self.kw)
+            if r.status_code == 404:
+                raise FileNotFoundError(path)
+            r.raise_for_status()
+            sha = r.json()["sha"]
+
+        # Delete the file
+        delete_url = self.content_url.format(
+            org=self.org, repo=self.repo, path=path, sha=self.root
+        )
+        branch = self.root
+        data = {
+            "message": message or f"Delete {path}",
+            "sha": sha,
+            **({"branch": branch} if branch else {}),
+        }
+
+        r = requests.delete(delete_url, json=data, timeout=self.timeout, **self.kw)
+        error_message = r.json().get("message", "")
+        if re.search(r"Branch .+ not found", error_message):
+            error = "Remove only works when the filesystem is initialised from a branch or default (None)"
+            raise ValueError(error)
+        r.raise_for_status()
+
+        self.invalidate_cache(path)
+
+    def _get_sha_from_cache(self, path):
+        for entries in self.dircache.values():
+            for entry in entries:
+                entry_path = entry.get("name")
+                if entry_path and entry_path == path and "sha" in entry:
+                    return entry["sha"]
+        return None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http.py
new file mode 100644
index 0000000000000000000000000000000000000000..aff1a955c27091229513b988627de9e806dca8c5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http.py
@@ -0,0 +1,902 @@
+import asyncio
+import io
+import logging
+import re
+import weakref
+from copy import copy
+from urllib.parse import urlparse
+
+import aiohttp
+import yarl
+
+from fsspec.asyn import AbstractAsyncStreamedFile, AsyncFileSystem, sync, sync_wrapper
+from fsspec.callbacks import DEFAULT_CALLBACK
+from fsspec.exceptions import FSTimeoutError
+from fsspec.spec import AbstractBufferedFile
+from fsspec.utils import (
+    DEFAULT_BLOCK_SIZE,
+    glob_translate,
+    isfilelike,
+    nullcontext,
+    tokenize,
+)
+
+from ..caching import AllBytes
+
+# https://stackoverflow.com/a/15926317/3821154
+ex = re.compile(r"""<(a|A)\s+(?:[^>]*?\s+)?(href|HREF)=["'](?P<url>[^"']+)""")
+ex2 = re.compile(r"""(?P<url>http[s]?://[-a-zA-Z0-9@:%_+.~#?&/=]+)""")
+logger = logging.getLogger("fsspec.http")
+
+
+async def get_client(**kwargs):
+    return aiohttp.ClientSession(**kwargs)
+
+
+class HTTPFileSystem(AsyncFileSystem):
+    """
+    Simple File-System for fetching data via HTTP(S)
+
+    ``ls()`` is implemented by loading the parent page and doing a regex
+    match on the result. If simple_link=True, anything of the form
+    "http(s)://server.com/stuff?thing=other"; otherwise only links within
+    HTML href tags will be used.
+
+    URLs are passed unfiltered to aiohttp, so all addresses are accessible. Where URLs are
+    supplied by a user, the calling application may wish to filter to prevent scanning.
+    """
+
+    protocol = ("http", "https")
+    sep = "/"
+
+    def __init__(
+        self,
+        simple_links=True,
+        block_size=None,
+        same_scheme=True,
+        size_policy=None,
+        cache_type="bytes",
+        cache_options=None,
+        asynchronous=False,
+        loop=None,
+        client_kwargs=None,
+        get_client=get_client,
+        encoded=False,
+        **storage_options,
+    ):
+        """
+        NB: if this is called async, you must await set_client
+
+        Parameters
+        ----------
+        block_size: int
+            Blocks to read bytes; if 0, will default to raw requests file-like
+            objects instead of HTTPFile instances
+        simple_links: bool
+            If True, will consider both HTML <a> tags and anything that looks
+            like a URL; if False, will consider only the former.
+        same_scheme: True
+            When doing ls/glob, if this is True, only consider paths that have
+            http/https matching the input URLs.
+        size_policy: this argument is deprecated
+        client_kwargs: dict
+            Passed to aiohttp.ClientSession, see
+            https://docs.aiohttp.org/en/stable/client_reference.html
+            For example, ``{'auth': aiohttp.BasicAuth('user', 'pass')}``
+        get_client: Callable[..., aiohttp.ClientSession]
+            A callable, which takes keyword arguments and constructs
+            an aiohttp.ClientSession. Its state will be managed by
+            the HTTPFileSystem class.
+        storage_options: key-value
+            Any other parameters passed on to requests
+        cache_type, cache_options: defaults used in open()
+        """
+        super().__init__(self, asynchronous=asynchronous, loop=loop, **storage_options)
+        self.block_size = block_size if block_size is not None else DEFAULT_BLOCK_SIZE
+        self.simple_links = simple_links
+        self.same_schema = same_scheme
+        self.cache_type = cache_type
+        self.cache_options = cache_options
+        self.client_kwargs = client_kwargs or {}
+        self.get_client = get_client
+        self.encoded = encoded
+        self.kwargs = storage_options
+        self._session = None
+
+        # Clean caching-related parameters from `storage_options`
+        # before propagating them as `request_options` through `self.kwargs`.
+        # TODO: Maybe rename `self.kwargs` to `self.request_options` to make
+        #       it clearer.
+        request_options = copy(storage_options)
+        self.use_listings_cache = request_options.pop("use_listings_cache", False)
+        request_options.pop("listings_expiry_time", None)
+        request_options.pop("max_paths", None)
+        request_options.pop("skip_instance_cache", None)
+        self.kwargs = request_options
+
+    @property
+    def fsid(self):
+        return "http"
+
+    def encode_url(self, url):
+        return yarl.URL(url, encoded=self.encoded)
+
+    @staticmethod
+    def close_session(loop, session):
+        if loop is not None and loop.is_running():
+            try:
+                sync(loop, session.close, timeout=0.1)
+                return
+            except (TimeoutError, FSTimeoutError, NotImplementedError):
+                pass
+        connector = getattr(session, "_connector", None)
+        if connector is not None:
+            # close after loop is dead
+            connector._close()
+
+    async def set_session(self):
+        if self._session is None:
+            self._session = await self.get_client(loop=self.loop, **self.client_kwargs)
+            if not self.asynchronous:
+                weakref.finalize(self, self.close_session, self.loop, self._session)
+        return self._session
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        """For HTTP, we always want to keep the full URL"""
+        return path
+
+    @classmethod
+    def _parent(cls, path):
+        # override, since _strip_protocol is different for URLs
+        par = super()._parent(path)
+        if len(par) > 7:  # "http://..."
+            return par
+        return ""
+
+    async def _ls_real(self, url, detail=True, **kwargs):
+        # ignoring URL-encoded arguments
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+        session = await self.set_session()
+        async with session.get(self.encode_url(url), **self.kwargs) as r:
+            self._raise_not_found_for_status(r, url)
+
+            if "Content-Type" in r.headers:
+                mimetype = r.headers["Content-Type"].partition(";")[0]
+            else:
+                mimetype = None
+
+            if mimetype in ("text/html", None):
+                try:
+                    text = await r.text(errors="ignore")
+                    if self.simple_links:
+                        links = ex2.findall(text) + [u[2] for u in ex.findall(text)]
+                    else:
+                        links = [u[2] for u in ex.findall(text)]
+                except UnicodeDecodeError:
+                    links = []  # binary, not HTML
+            else:
+                links = []
+
+        out = set()
+        parts = urlparse(url)
+        for l in links:
+            if isinstance(l, tuple):
+                l = l[1]
+            if l.startswith("/") and len(l) > 1:
+                # absolute URL on this server
+                l = f"{parts.scheme}://{parts.netloc}{l}"
+            if l.startswith("http"):
+                if self.same_schema and l.startswith(url.rstrip("/") + "/"):
+                    out.add(l)
+                elif l.replace("https", "http").startswith(
+                    url.replace("https", "http").rstrip("/") + "/"
+                ):
+                    # allowed to cross http <-> https
+                    out.add(l)
+            else:
+                if l not in ["..", "../"]:
+                    # Ignore FTP-like "parent"
+                    out.add("/".join([url.rstrip("/"), l.lstrip("/")]))
+        if not out and url.endswith("/"):
+            out = await self._ls_real(url.rstrip("/"), detail=False)
+        if detail:
+            return [
+                {
+                    "name": u,
+                    "size": None,
+                    "type": "directory" if u.endswith("/") else "file",
+                }
+                for u in out
+            ]
+        else:
+            return sorted(out)
+
+    async def _ls(self, url, detail=True, **kwargs):
+        if self.use_listings_cache and url in self.dircache:
+            out = self.dircache[url]
+        else:
+            out = await self._ls_real(url, detail=detail, **kwargs)
+            self.dircache[url] = out
+        return out
+
+    ls = sync_wrapper(_ls)
+
+    def _raise_not_found_for_status(self, response, url):
+        """
+        Raises FileNotFoundError for 404s, otherwise uses raise_for_status.
+        """
+        if response.status == 404:
+            raise FileNotFoundError(url)
+        response.raise_for_status()
+
+    async def _cat_file(self, url, start=None, end=None, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+
+        if start is not None or end is not None:
+            if start == end:
+                return b""
+            headers = kw.pop("headers", {}).copy()
+
+            headers["Range"] = await self._process_limits(url, start, end)
+            kw["headers"] = headers
+        session = await self.set_session()
+        async with session.get(self.encode_url(url), **kw) as r:
+            out = await r.read()
+            self._raise_not_found_for_status(r, url)
+        return out
+
+    async def _get_file(
+        self, rpath, lpath, chunk_size=5 * 2**20, callback=DEFAULT_CALLBACK, **kwargs
+    ):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(rpath)
+        session = await self.set_session()
+        async with session.get(self.encode_url(rpath), **kw) as r:
+            try:
+                size = int(r.headers["content-length"])
+            except (ValueError, KeyError):
+                size = None
+
+            callback.set_size(size)
+            self._raise_not_found_for_status(r, rpath)
+            if isfilelike(lpath):
+                outfile = lpath
+            else:
+                outfile = open(lpath, "wb")  # noqa: ASYNC230
+
+            try:
+                chunk = True
+                while chunk:
+                    chunk = await r.content.read(chunk_size)
+                    outfile.write(chunk)
+                    callback.relative_update(len(chunk))
+            finally:
+                if not isfilelike(lpath):
+                    outfile.close()
+
+    async def _put_file(
+        self,
+        lpath,
+        rpath,
+        chunk_size=5 * 2**20,
+        callback=DEFAULT_CALLBACK,
+        method="post",
+        mode="overwrite",
+        **kwargs,
+    ):
+        if mode != "overwrite":
+            raise NotImplementedError("Exclusive write")
+
+        async def gen_chunks():
+            # Support passing arbitrary file-like objects
+            # and use them instead of streams.
+            if isinstance(lpath, io.IOBase):
+                context = nullcontext(lpath)
+                use_seek = False  # might not support seeking
+            else:
+                context = open(lpath, "rb")  # noqa: ASYNC230
+                use_seek = True
+
+            with context as f:
+                if use_seek:
+                    callback.set_size(f.seek(0, 2))
+                    f.seek(0)
+                else:
+                    callback.set_size(getattr(f, "size", None))
+
+                chunk = f.read(chunk_size)
+                while chunk:
+                    yield chunk
+                    callback.relative_update(len(chunk))
+                    chunk = f.read(chunk_size)
+
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        session = await self.set_session()
+
+        method = method.lower()
+        if method not in ("post", "put"):
+            raise ValueError(
+                f"method has to be either 'post' or 'put', not: {method!r}"
+            )
+
+        meth = getattr(session, method)
+        async with meth(self.encode_url(rpath), data=gen_chunks(), **kw) as resp:
+            self._raise_not_found_for_status(resp, rpath)
+
+    async def _exists(self, path, strict=False, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        try:
+            logger.debug(path)
+            session = await self.set_session()
+            r = await session.get(self.encode_url(path), **kw)
+            async with r:
+                if strict:
+                    self._raise_not_found_for_status(r, path)
+                return r.status < 400
+        except FileNotFoundError:
+            return False
+        except aiohttp.ClientError:
+            if strict:
+                raise
+            return False
+
+    async def _isfile(self, path, **kwargs):
+        return await self._exists(path, **kwargs)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=None,  # XXX: This differs from the base class.
+        cache_type=None,
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        """Make a file-like object
+
+        Parameters
+        ----------
+        path: str
+            Full URL with protocol
+        mode: string
+            must be "rb"
+        block_size: int or None
+            Bytes to download in one request; use instance value if None. If
+            zero, will return a streaming Requests file-like instance.
+        kwargs: key-value
+            Any other parameters, passed to requests calls
+        """
+        if mode != "rb":
+            raise NotImplementedError
+        block_size = block_size if block_size is not None else self.block_size
+        kw = self.kwargs.copy()
+        kw["asynchronous"] = self.asynchronous
+        kw.update(kwargs)
+        info = {}
+        size = size or info.update(self.info(path, **kwargs)) or info["size"]
+        session = sync(self.loop, self.set_session)
+        if block_size and size and info.get("partial", True):
+            return HTTPFile(
+                self,
+                path,
+                session=session,
+                block_size=block_size,
+                mode=mode,
+                size=size,
+                cache_type=cache_type or self.cache_type,
+                cache_options=cache_options or self.cache_options,
+                loop=self.loop,
+                **kw,
+            )
+        else:
+            return HTTPStreamFile(
+                self,
+                path,
+                mode=mode,
+                loop=self.loop,
+                session=session,
+                **kw,
+            )
+
+    async def open_async(self, path, mode="rb", size=None, **kwargs):
+        session = await self.set_session()
+        if size is None:
+            try:
+                size = (await self._info(path, **kwargs))["size"]
+            except FileNotFoundError:
+                pass
+        return AsyncStreamFile(
+            self,
+            path,
+            loop=self.loop,
+            session=session,
+            size=size,
+            **kwargs,
+        )
+
+    def ukey(self, url):
+        """Unique identifier; assume HTTP files are static, unchanging"""
+        return tokenize(url, self.kwargs, self.protocol)
+
+    async def _info(self, url, **kwargs):
+        """Get info of URL
+
+        Tries to access location via HEAD, and then GET methods, but does
+        not fetch the data.
+
+        It is possible that the server does not supply any size information, in
+        which case size will be given as None (and certain operations on the
+        corresponding file will not work).
+        """
+        info = {}
+        session = await self.set_session()
+
+        for policy in ["head", "get"]:
+            try:
+                info.update(
+                    await _file_info(
+                        self.encode_url(url),
+                        size_policy=policy,
+                        session=session,
+                        **self.kwargs,
+                        **kwargs,
+                    )
+                )
+                if info.get("size") is not None:
+                    break
+            except Exception as exc:
+                if policy == "get":
+                    # If get failed, then raise a FileNotFoundError
+                    raise FileNotFoundError(url) from exc
+                logger.debug("", exc_info=exc)
+
+        return {"name": url, "size": None, **info, "type": "file"}
+
+    async def _glob(self, path, maxdepth=None, **kwargs):
+        """
+        Find files by glob-matching.
+
+        This implementation is idntical to the one in AbstractFileSystem,
+        but "?" is not considered as a character for globbing, because it is
+        so common in URLs, often identifying the "query" part.
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+        import re
+
+        ends_with_slash = path.endswith("/")  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_slash or path.endswith(("/**", "/*"))
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+
+        if not has_magic(path):
+            if await self._exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: await self._info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            min_idx = path[:min_idx].rindex("/")
+            root = path[: min_idx + 1]
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        allpaths = await self._find(
+            root, maxdepth=depth, withdirs=True, detail=True, **kwargs
+        )
+
+        pattern = glob_translate(path + ("/" if ends_with_slash else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            (
+                p.rstrip("/")
+                if not append_slash_to_dirname
+                and info["type"] == "directory"
+                and p.endswith("/")
+                else p
+            ): info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(p.rstrip("/"))
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    async def _isdir(self, path):
+        # override, since all URLs are (also) files
+        try:
+            return bool(await self._ls(path))
+        except (FileNotFoundError, ValueError):
+            return False
+
+    async def _pipe_file(self, path, value, mode="overwrite", **kwargs):
+        """
+        Write bytes to a remote file over HTTP.
+
+        Parameters
+        ----------
+        path : str
+            Target URL where the data should be written
+        value : bytes
+            Data to be written
+        mode : str
+            How to write to the file - 'overwrite' or 'append'
+        **kwargs : dict
+            Additional parameters to pass to the HTTP request
+        """
+        url = self._strip_protocol(path)
+        headers = kwargs.pop("headers", {})
+        headers["Content-Length"] = str(len(value))
+
+        session = await self.set_session()
+
+        async with session.put(
+            self.encode_url(url), data=value, headers=headers, **kwargs
+        ) as r:
+            r.raise_for_status()
+
+
+class HTTPFile(AbstractBufferedFile):
+    """
+    A file-like object pointing to a remote HTTP(S) resource
+
+    Supports only reading, with read-ahead of a predetermined block-size.
+
+    In the case that the server does not supply the filesize, only reading of
+    the complete file in one go is supported.
+
+    Parameters
+    ----------
+    url: str
+        Full URL of the remote resource, including the protocol
+    session: aiohttp.ClientSession or None
+        All calls will be made within this session, to avoid restarting
+        connections where the server allows this
+    block_size: int or None
+        The amount of read-ahead to do, in bytes. Default is 5MB, or the value
+        configured for the FileSystem creating this file
+    size: None or int
+        If given, this is the size of the file in bytes, and we don't attempt
+        to call the server to find the value.
+    kwargs: all other key-values are passed to requests calls.
+    """
+
+    def __init__(
+        self,
+        fs,
+        url,
+        session=None,
+        block_size=None,
+        mode="rb",
+        cache_type="bytes",
+        cache_options=None,
+        size=None,
+        loop=None,
+        asynchronous=False,
+        **kwargs,
+    ):
+        if mode != "rb":
+            raise NotImplementedError("File mode not supported")
+        self.asynchronous = asynchronous
+        self.loop = loop
+        self.url = url
+        self.session = session
+        self.details = {"name": url, "size": size, "type": "file"}
+        super().__init__(
+            fs=fs,
+            path=url,
+            mode=mode,
+            block_size=block_size,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def read(self, length=-1):
+        """Read bytes from file
+
+        Parameters
+        ----------
+        length: int
+            Read up to this many bytes. If negative, read all content to end of
+            file. If the server has not supplied the filesize, attempting to
+            read only part of the data will raise a ValueError.
+        """
+        if (
+            (length < 0 and self.loc == 0)  # explicit read all
+            # but not when the size is known and fits into a block anyways
+            and not (self.size is not None and self.size <= self.blocksize)
+        ):
+            self._fetch_all()
+        if self.size is None:
+            if length < 0:
+                self._fetch_all()
+        else:
+            length = min(self.size - self.loc, length)
+        return super().read(length)
+
+    async def async_fetch_all(self):
+        """Read whole file in one shot, without caching
+
+        This is only called when position is still at zero,
+        and read() is called without a byte-count.
+        """
+        logger.debug(f"Fetch all for {self}")
+        if not isinstance(self.cache, AllBytes):
+            r = await self.session.get(self.fs.encode_url(self.url), **self.kwargs)
+            async with r:
+                r.raise_for_status()
+                out = await r.read()
+                self.cache = AllBytes(
+                    size=len(out), fetcher=None, blocksize=None, data=out
+                )
+                self.size = len(out)
+
+    _fetch_all = sync_wrapper(async_fetch_all)
+
+    def _parse_content_range(self, headers):
+        """Parse the Content-Range header"""
+        s = headers.get("Content-Range", "")
+        m = re.match(r"bytes (\d+-\d+|\*)/(\d+|\*)", s)
+        if not m:
+            return None, None, None
+
+        if m[1] == "*":
+            start = end = None
+        else:
+            start, end = [int(x) for x in m[1].split("-")]
+        total = None if m[2] == "*" else int(m[2])
+        return start, end, total
+
+    async def async_fetch_range(self, start, end):
+        """Download a block of data
+
+        The expectation is that the server returns only the requested bytes,
+        with HTTP code 206. If this is not the case, we first check the headers,
+        and then stream the output - if the data size is bigger than we
+        requested, an exception is raised.
+        """
+        logger.debug(f"Fetch range for {self}: {start}-{end}")
+        kwargs = self.kwargs.copy()
+        headers = kwargs.pop("headers", {}).copy()
+        headers["Range"] = f"bytes={start}-{end - 1}"
+        logger.debug(f"{self.url} : {headers['Range']}")
+        r = await self.session.get(
+            self.fs.encode_url(self.url), headers=headers, **kwargs
+        )
+        async with r:
+            if r.status == 416:
+                # range request outside file
+                return b""
+            r.raise_for_status()
+
+            # If the server has handled the range request, it should reply
+            # with status 206 (partial content). But we'll guess that a suitable
+            # Content-Range header or a Content-Length no more than the
+            # requested range also mean we have got the desired range.
+            response_is_range = (
+                r.status == 206
+                or self._parse_content_range(r.headers)[0] == start
+                or int(r.headers.get("Content-Length", end + 1)) <= end - start
+            )
+
+            if response_is_range:
+                # partial content, as expected
+                out = await r.read()
+            elif start > 0:
+                raise ValueError(
+                    "The HTTP server doesn't appear to support range requests. "
+                    "Only reading this file from the beginning is supported. "
+                    "Open with block_size=0 for a streaming file interface."
+                )
+            else:
+                # Response is not a range, but we want the start of the file,
+                # so we can read the required amount anyway.
+                cl = 0
+                out = []
+                while True:
+                    chunk = await r.content.read(2**20)
+                    # data size unknown, let's read until we have enough
+                    if chunk:
+                        out.append(chunk)
+                        cl += len(chunk)
+                        if cl > end - start:
+                            break
+                    else:
+                        break
+                out = b"".join(out)[: end - start]
+            return out
+
+    _fetch_range = sync_wrapper(async_fetch_range)
+
+
+magic_check = re.compile("([*[])")
+
+
+def has_magic(s):
+    match = magic_check.search(s)
+    return match is not None
+
+
+class HTTPStreamFile(AbstractBufferedFile):
+    def __init__(self, fs, url, mode="rb", loop=None, session=None, **kwargs):
+        self.asynchronous = kwargs.pop("asynchronous", False)
+        self.url = url
+        self.loop = loop
+        self.session = session
+        if mode != "rb":
+            raise ValueError
+        self.details = {"name": url, "size": None}
+        super().__init__(fs=fs, path=url, mode=mode, cache_type="none", **kwargs)
+
+        async def cor():
+            r = await self.session.get(self.fs.encode_url(url), **kwargs).__aenter__()
+            self.fs._raise_not_found_for_status(r, url)
+            return r
+
+        self.r = sync(self.loop, cor)
+        self.loop = fs.loop
+
+    def seek(self, loc, whence=0):
+        if loc == 0 and whence == 1:
+            return
+        if loc == self.loc and whence == 0:
+            return
+        raise ValueError("Cannot seek streaming HTTP file")
+
+    async def _read(self, num=-1):
+        out = await self.r.content.read(num)
+        self.loc += len(out)
+        return out
+
+    read = sync_wrapper(_read)
+
+    async def _close(self):
+        self.r.close()
+
+    def close(self):
+        asyncio.run_coroutine_threadsafe(self._close(), self.loop)
+        super().close()
+
+
+class AsyncStreamFile(AbstractAsyncStreamedFile):
+    def __init__(
+        self, fs, url, mode="rb", loop=None, session=None, size=None, **kwargs
+    ):
+        self.url = url
+        self.session = session
+        self.r = None
+        if mode != "rb":
+            raise ValueError
+        self.details = {"name": url, "size": None}
+        self.kwargs = kwargs
+        super().__init__(fs=fs, path=url, mode=mode, cache_type="none")
+        self.size = size
+
+    async def read(self, num=-1):
+        if self.r is None:
+            r = await self.session.get(
+                self.fs.encode_url(self.url), **self.kwargs
+            ).__aenter__()
+            self.fs._raise_not_found_for_status(r, self.url)
+            self.r = r
+        out = await self.r.content.read(num)
+        self.loc += len(out)
+        return out
+
+    async def close(self):
+        if self.r is not None:
+            self.r.close()
+            self.r = None
+        await super().close()
+
+
+async def get_range(session, url, start, end, file=None, **kwargs):
+    # explicit get a range when we know it must be safe
+    kwargs = kwargs.copy()
+    headers = kwargs.pop("headers", {}).copy()
+    headers["Range"] = f"bytes={start}-{end - 1}"
+    r = await session.get(url, headers=headers, **kwargs)
+    r.raise_for_status()
+    async with r:
+        out = await r.read()
+    if file:
+        with open(file, "r+b") as f:  # noqa: ASYNC230
+            f.seek(start)
+            f.write(out)
+    else:
+        return out
+
+
+async def _file_info(url, session, size_policy="head", **kwargs):
+    """Call HEAD on the server to get details about the file (size/checksum etc.)
+
+    Default operation is to explicitly allow redirects and use encoding
+    'identity' (no compression) to get the true size of the target.
+    """
+    logger.debug("Retrieve file size for %s", url)
+    kwargs = kwargs.copy()
+    ar = kwargs.pop("allow_redirects", True)
+    head = kwargs.get("headers", {}).copy()
+    head["Accept-Encoding"] = "identity"
+    kwargs["headers"] = head
+
+    info = {}
+    if size_policy == "head":
+        r = await session.head(url, allow_redirects=ar, **kwargs)
+    elif size_policy == "get":
+        r = await session.get(url, allow_redirects=ar, **kwargs)
+    else:
+        raise TypeError(f'size_policy must be "head" or "get", got {size_policy}')
+    async with r:
+        r.raise_for_status()
+
+        if "Content-Length" in r.headers:
+            # Some servers may choose to ignore Accept-Encoding and return
+            # compressed content, in which case the returned size is unreliable.
+            if "Content-Encoding" not in r.headers or r.headers["Content-Encoding"] in [
+                "identity",
+                "",
+            ]:
+                info["size"] = int(r.headers["Content-Length"])
+        elif "Content-Range" in r.headers:
+            info["size"] = int(r.headers["Content-Range"].split("/")[1])
+
+        if "Content-Type" in r.headers:
+            info["mimetype"] = r.headers["Content-Type"].partition(";")[0]
+
+        if r.headers.get("Accept-Ranges") == "none":
+            # Some servers may explicitly discourage partial content requests, but
+            # the lack of "Accept-Ranges" does not always indicate they would fail
+            info["partial"] = False
+
+        info["url"] = str(r.url)
+
+        for checksum_field in ["ETag", "Content-MD5", "Digest", "Last-Modified"]:
+            if r.headers.get(checksum_field):
+                info[checksum_field] = r.headers[checksum_field]
+
+    return info
+
+
+async def _file_size(url, session=None, *args, **kwargs):
+    if session is None:
+        session = await get_client()
+    info = await _file_info(url, session=session, *args, **kwargs)
+    return info.get("size")
+
+
+file_size = sync_wrapper(_file_size)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http_sync.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http_sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..a67ea3ea5fee9e6b51f7f3f66773e8cf65735e52
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/http_sync.py
@@ -0,0 +1,937 @@
+"""This file is largely copied from http.py"""
+
+import io
+import logging
+import re
+import urllib.error
+import urllib.parse
+from copy import copy
+from json import dumps, loads
+from urllib.parse import urlparse
+
+try:
+    import yarl
+except (ImportError, ModuleNotFoundError, OSError):
+    yarl = False
+
+from fsspec.callbacks import _DEFAULT_CALLBACK
+from fsspec.registry import register_implementation
+from fsspec.spec import AbstractBufferedFile, AbstractFileSystem
+from fsspec.utils import DEFAULT_BLOCK_SIZE, isfilelike, nullcontext, tokenize
+
+from ..caching import AllBytes
+
+# https://stackoverflow.com/a/15926317/3821154
+ex = re.compile(r"""<(a|A)\s+(?:[^>]*?\s+)?(href|HREF)=["'](?P<url>[^"']+)""")
+ex2 = re.compile(r"""(?P<url>http[s]?://[-a-zA-Z0-9@:%_+.~#?&/=]+)""")
+logger = logging.getLogger("fsspec.http")
+
+
+class JsHttpException(urllib.error.HTTPError): ...
+
+
+class StreamIO(io.BytesIO):
+    # fake class, so you can set attributes on it
+    # will eventually actually stream
+    ...
+
+
+class ResponseProxy:
+    """Looks like a requests response"""
+
+    def __init__(self, req, stream=False):
+        self.request = req
+        self.stream = stream
+        self._data = None
+        self._headers = None
+
+    @property
+    def raw(self):
+        if self._data is None:
+            b = self.request.response.to_bytes()
+            if self.stream:
+                self._data = StreamIO(b)
+            else:
+                self._data = b
+        return self._data
+
+    def close(self):
+        if hasattr(self, "_data"):
+            del self._data
+
+    @property
+    def headers(self):
+        if self._headers is None:
+            self._headers = dict(
+                [
+                    _.split(": ")
+                    for _ in self.request.getAllResponseHeaders().strip().split("\r\n")
+                ]
+            )
+        return self._headers
+
+    @property
+    def status_code(self):
+        return int(self.request.status)
+
+    def raise_for_status(self):
+        if not self.ok:
+            raise JsHttpException(
+                self.url, self.status_code, self.reason, self.headers, None
+            )
+
+    def iter_content(self, chunksize, *_, **__):
+        while True:
+            out = self.raw.read(chunksize)
+            if out:
+                yield out
+            else:
+                break
+
+    @property
+    def reason(self):
+        return self.request.statusText
+
+    @property
+    def ok(self):
+        return self.status_code < 400
+
+    @property
+    def url(self):
+        return self.request.response.responseURL
+
+    @property
+    def text(self):
+        # TODO: encoding from headers
+        return self.content.decode()
+
+    @property
+    def content(self):
+        self.stream = False
+        return self.raw
+
+    def json(self):
+        return loads(self.text)
+
+
+class RequestsSessionShim:
+    def __init__(self):
+        self.headers = {}
+
+    def request(
+        self,
+        method,
+        url,
+        params=None,
+        data=None,
+        headers=None,
+        cookies=None,
+        files=None,
+        auth=None,
+        timeout=None,
+        allow_redirects=None,
+        proxies=None,
+        hooks=None,
+        stream=None,
+        verify=None,
+        cert=None,
+        json=None,
+    ):
+        from js import Blob, XMLHttpRequest
+
+        logger.debug("JS request: %s %s", method, url)
+
+        if cert or verify or proxies or files or cookies or hooks:
+            raise NotImplementedError
+        if data and json:
+            raise ValueError("Use json= or data=, not both")
+        req = XMLHttpRequest.new()
+        extra = auth if auth else ()
+        if params:
+            url = f"{url}?{urllib.parse.urlencode(params)}"
+        req.open(method, url, False, *extra)
+        if timeout:
+            req.timeout = timeout
+        if headers:
+            for k, v in headers.items():
+                req.setRequestHeader(k, v)
+
+        req.setRequestHeader("Accept", "application/octet-stream")
+        req.responseType = "arraybuffer"
+        if json:
+            blob = Blob.new([dumps(data)], {type: "application/json"})
+            req.send(blob)
+        elif data:
+            if isinstance(data, io.IOBase):
+                data = data.read()
+            blob = Blob.new([data], {type: "application/octet-stream"})
+            req.send(blob)
+        else:
+            req.send(None)
+        return ResponseProxy(req, stream=stream)
+
+    def get(self, url, **kwargs):
+        return self.request("GET", url, **kwargs)
+
+    def head(self, url, **kwargs):
+        return self.request("HEAD", url, **kwargs)
+
+    def post(self, url, **kwargs):
+        return self.request("POST}", url, **kwargs)
+
+    def put(self, url, **kwargs):
+        return self.request("PUT", url, **kwargs)
+
+    def patch(self, url, **kwargs):
+        return self.request("PATCH", url, **kwargs)
+
+    def delete(self, url, **kwargs):
+        return self.request("DELETE", url, **kwargs)
+
+
+class HTTPFileSystem(AbstractFileSystem):
+    """
+    Simple File-System for fetching data via HTTP(S)
+
+    This is the BLOCKING version of the normal HTTPFileSystem. It uses
+    requests in normal python and the JS runtime in pyodide.
+
+    ***This implementation is extremely experimental, do not use unless
+    you are testing pyodide/pyscript integration***
+    """
+
+    protocol = ("http", "https", "sync-http", "sync-https")
+    sep = "/"
+
+    def __init__(
+        self,
+        simple_links=True,
+        block_size=None,
+        same_scheme=True,
+        cache_type="readahead",
+        cache_options=None,
+        client_kwargs=None,
+        encoded=False,
+        **storage_options,
+    ):
+        """
+
+        Parameters
+        ----------
+        block_size: int
+            Blocks to read bytes; if 0, will default to raw requests file-like
+            objects instead of HTTPFile instances
+        simple_links: bool
+            If True, will consider both HTML <a> tags and anything that looks
+            like a URL; if False, will consider only the former.
+        same_scheme: True
+            When doing ls/glob, if this is True, only consider paths that have
+            http/https matching the input URLs.
+        size_policy: this argument is deprecated
+        client_kwargs: dict
+            Passed to aiohttp.ClientSession, see
+            https://docs.aiohttp.org/en/stable/client_reference.html
+            For example, ``{'auth': aiohttp.BasicAuth('user', 'pass')}``
+        storage_options: key-value
+            Any other parameters passed on to requests
+        cache_type, cache_options: defaults used in open
+        """
+        super().__init__(self, **storage_options)
+        self.block_size = block_size if block_size is not None else DEFAULT_BLOCK_SIZE
+        self.simple_links = simple_links
+        self.same_schema = same_scheme
+        self.cache_type = cache_type
+        self.cache_options = cache_options
+        self.client_kwargs = client_kwargs or {}
+        self.encoded = encoded
+        self.kwargs = storage_options
+
+        try:
+            import js  # noqa: F401
+
+            logger.debug("Starting JS session")
+            self.session = RequestsSessionShim()
+            self.js = True
+        except Exception as e:
+            import requests
+
+            logger.debug("Starting cpython session because of: %s", e)
+            self.session = requests.Session(**(client_kwargs or {}))
+            self.js = False
+
+        request_options = copy(storage_options)
+        self.use_listings_cache = request_options.pop("use_listings_cache", False)
+        request_options.pop("listings_expiry_time", None)
+        request_options.pop("max_paths", None)
+        request_options.pop("skip_instance_cache", None)
+        self.kwargs = request_options
+
+    @property
+    def fsid(self):
+        return "sync-http"
+
+    def encode_url(self, url):
+        if yarl:
+            return yarl.URL(url, encoded=self.encoded)
+        return url
+
+    @classmethod
+    def _strip_protocol(cls, path: str) -> str:
+        """For HTTP, we always want to keep the full URL"""
+        path = path.replace("sync-http://", "http://").replace(
+            "sync-https://", "https://"
+        )
+        return path
+
+    @classmethod
+    def _parent(cls, path):
+        # override, since _strip_protocol is different for URLs
+        par = super()._parent(path)
+        if len(par) > 7:  # "http://..."
+            return par
+        return ""
+
+    def _ls_real(self, url, detail=True, **kwargs):
+        # ignoring URL-encoded arguments
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+        r = self.session.get(self.encode_url(url), **self.kwargs)
+        self._raise_not_found_for_status(r, url)
+        text = r.text
+        if self.simple_links:
+            links = ex2.findall(text) + [u[2] for u in ex.findall(text)]
+        else:
+            links = [u[2] for u in ex.findall(text)]
+        out = set()
+        parts = urlparse(url)
+        for l in links:
+            if isinstance(l, tuple):
+                l = l[1]
+            if l.startswith("/") and len(l) > 1:
+                # absolute URL on this server
+                l = parts.scheme + "://" + parts.netloc + l
+            if l.startswith("http"):
+                if self.same_schema and l.startswith(url.rstrip("/") + "/"):
+                    out.add(l)
+                elif l.replace("https", "http").startswith(
+                    url.replace("https", "http").rstrip("/") + "/"
+                ):
+                    # allowed to cross http <-> https
+                    out.add(l)
+            else:
+                if l not in ["..", "../"]:
+                    # Ignore FTP-like "parent"
+                    out.add("/".join([url.rstrip("/"), l.lstrip("/")]))
+        if not out and url.endswith("/"):
+            out = self._ls_real(url.rstrip("/"), detail=False)
+        if detail:
+            return [
+                {
+                    "name": u,
+                    "size": None,
+                    "type": "directory" if u.endswith("/") else "file",
+                }
+                for u in out
+            ]
+        else:
+            return sorted(out)
+
+    def ls(self, url, detail=True, **kwargs):
+        if self.use_listings_cache and url in self.dircache:
+            out = self.dircache[url]
+        else:
+            out = self._ls_real(url, detail=detail, **kwargs)
+            self.dircache[url] = out
+        return out
+
+    def _raise_not_found_for_status(self, response, url):
+        """
+        Raises FileNotFoundError for 404s, otherwise uses raise_for_status.
+        """
+        if response.status_code == 404:
+            raise FileNotFoundError(url)
+        response.raise_for_status()
+
+    def cat_file(self, url, start=None, end=None, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(url)
+
+        if start is not None or end is not None:
+            if start == end:
+                return b""
+            headers = kw.pop("headers", {}).copy()
+
+            headers["Range"] = self._process_limits(url, start, end)
+            kw["headers"] = headers
+        r = self.session.get(self.encode_url(url), **kw)
+        self._raise_not_found_for_status(r, url)
+        return r.content
+
+    def get_file(
+        self, rpath, lpath, chunk_size=5 * 2**20, callback=_DEFAULT_CALLBACK, **kwargs
+    ):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        logger.debug(rpath)
+        r = self.session.get(self.encode_url(rpath), **kw)
+        try:
+            size = int(
+                r.headers.get("content-length", None)
+                or r.headers.get("Content-Length", None)
+            )
+        except (ValueError, KeyError, TypeError):
+            size = None
+
+        callback.set_size(size)
+        self._raise_not_found_for_status(r, rpath)
+        if not isfilelike(lpath):
+            lpath = open(lpath, "wb")
+        for chunk in r.iter_content(chunk_size, decode_unicode=False):
+            lpath.write(chunk)
+            callback.relative_update(len(chunk))
+
+    def put_file(
+        self,
+        lpath,
+        rpath,
+        chunk_size=5 * 2**20,
+        callback=_DEFAULT_CALLBACK,
+        method="post",
+        **kwargs,
+    ):
+        def gen_chunks():
+            # Support passing arbitrary file-like objects
+            # and use them instead of streams.
+            if isinstance(lpath, io.IOBase):
+                context = nullcontext(lpath)
+                use_seek = False  # might not support seeking
+            else:
+                context = open(lpath, "rb")
+                use_seek = True
+
+            with context as f:
+                if use_seek:
+                    callback.set_size(f.seek(0, 2))
+                    f.seek(0)
+                else:
+                    callback.set_size(getattr(f, "size", None))
+
+                chunk = f.read(chunk_size)
+                while chunk:
+                    yield chunk
+                    callback.relative_update(len(chunk))
+                    chunk = f.read(chunk_size)
+
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+
+        method = method.lower()
+        if method not in ("post", "put"):
+            raise ValueError(
+                f"method has to be either 'post' or 'put', not: {method!r}"
+            )
+
+        meth = getattr(self.session, method)
+        resp = meth(rpath, data=gen_chunks(), **kw)
+        self._raise_not_found_for_status(resp, rpath)
+
+    def _process_limits(self, url, start, end):
+        """Helper for "Range"-based _cat_file"""
+        size = None
+        suff = False
+        if start is not None and start < 0:
+            # if start is negative and end None, end is the "suffix length"
+            if end is None:
+                end = -start
+                start = ""
+                suff = True
+            else:
+                size = size or self.info(url)["size"]
+                start = size + start
+        elif start is None:
+            start = 0
+        if not suff:
+            if end is not None and end < 0:
+                if start is not None:
+                    size = size or self.info(url)["size"]
+                    end = size + end
+            elif end is None:
+                end = ""
+            if isinstance(end, int):
+                end -= 1  # bytes range is inclusive
+        return f"bytes={start}-{end}"
+
+    def exists(self, path, strict=False, **kwargs):
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        try:
+            logger.debug(path)
+            r = self.session.get(self.encode_url(path), **kw)
+            if strict:
+                self._raise_not_found_for_status(r, path)
+            return r.status_code < 400
+        except FileNotFoundError:
+            return False
+        except Exception:
+            if strict:
+                raise
+            return False
+
+    def isfile(self, path, **kwargs):
+        return self.exists(path, **kwargs)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=None,  # XXX: This differs from the base class.
+        cache_type=None,
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        """Make a file-like object
+
+        Parameters
+        ----------
+        path: str
+            Full URL with protocol
+        mode: string
+            must be "rb"
+        block_size: int or None
+            Bytes to download in one request; use instance value if None. If
+            zero, will return a streaming Requests file-like instance.
+        kwargs: key-value
+            Any other parameters, passed to requests calls
+        """
+        if mode != "rb":
+            raise NotImplementedError
+        block_size = block_size if block_size is not None else self.block_size
+        kw = self.kwargs.copy()
+        kw.update(kwargs)
+        size = size or self.info(path, **kwargs)["size"]
+        if block_size and size:
+            return HTTPFile(
+                self,
+                path,
+                session=self.session,
+                block_size=block_size,
+                mode=mode,
+                size=size,
+                cache_type=cache_type or self.cache_type,
+                cache_options=cache_options or self.cache_options,
+                **kw,
+            )
+        else:
+            return HTTPStreamFile(
+                self,
+                path,
+                mode=mode,
+                session=self.session,
+                **kw,
+            )
+
+    def ukey(self, url):
+        """Unique identifier; assume HTTP files are static, unchanging"""
+        return tokenize(url, self.kwargs, self.protocol)
+
+    def info(self, url, **kwargs):
+        """Get info of URL
+
+        Tries to access location via HEAD, and then GET methods, but does
+        not fetch the data.
+
+        It is possible that the server does not supply any size information, in
+        which case size will be given as None (and certain operations on the
+        corresponding file will not work).
+        """
+        info = {}
+        for policy in ["head", "get"]:
+            try:
+                info.update(
+                    _file_info(
+                        self.encode_url(url),
+                        size_policy=policy,
+                        session=self.session,
+                        **self.kwargs,
+                        **kwargs,
+                    )
+                )
+                if info.get("size") is not None:
+                    break
+            except Exception as exc:
+                if policy == "get":
+                    # If get failed, then raise a FileNotFoundError
+                    raise FileNotFoundError(url) from exc
+                logger.debug(str(exc))
+
+        return {"name": url, "size": None, **info, "type": "file"}
+
+    def glob(self, path, maxdepth=None, **kwargs):
+        """
+        Find files by glob-matching.
+
+        This implementation is idntical to the one in AbstractFileSystem,
+        but "?" is not considered as a character for globbing, because it is
+        so common in URLs, often identifying the "query" part.
+        """
+        import re
+
+        ends = path.endswith("/")
+        path = self._strip_protocol(path)
+        indstar = path.find("*") if path.find("*") >= 0 else len(path)
+        indbrace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        ind = min(indstar, indbrace)
+
+        detail = kwargs.pop("detail", False)
+
+        if not has_magic(path):
+            root = path
+            depth = 1
+            if ends:
+                path += "/*"
+            elif self.exists(path):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: self.info(path)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:ind]:
+            ind2 = path[:ind].rindex("/")
+            root = path[: ind2 + 1]
+            depth = None if "**" in path else path[ind2 + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = None if "**" in path else path[ind + 1 :].count("/") + 1
+
+        allpaths = self.find(
+            root, maxdepth=maxdepth or depth, withdirs=True, detail=True, **kwargs
+        )
+        # Escape characters special to python regex, leaving our supported
+        # special characters in place.
+        # See https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html
+        # for shell globbing details.
+        pattern = (
+            "^"
+            + (
+                path.replace("\\", r"\\")
+                .replace(".", r"\.")
+                .replace("+", r"\+")
+                .replace("//", "/")
+                .replace("(", r"\(")
+                .replace(")", r"\)")
+                .replace("|", r"\|")
+                .replace("^", r"\^")
+                .replace("$", r"\$")
+                .replace("{", r"\{")
+                .replace("}", r"\}")
+                .rstrip("/")
+            )
+            + "$"
+        )
+        pattern = re.sub("[*]{2}", "=PLACEHOLDER=", pattern)
+        pattern = re.sub("[*]", "[^/]*", pattern)
+        pattern = re.compile(pattern.replace("=PLACEHOLDER=", ".*"))
+        out = {
+            p: allpaths[p]
+            for p in sorted(allpaths)
+            if pattern.match(p.replace("//", "/").rstrip("/"))
+        }
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    def isdir(self, path):
+        # override, since all URLs are (also) files
+        try:
+            return bool(self.ls(path))
+        except (FileNotFoundError, ValueError):
+            return False
+
+
+class HTTPFile(AbstractBufferedFile):
+    """
+    A file-like object pointing to a remove HTTP(S) resource
+
+    Supports only reading, with read-ahead of a predermined block-size.
+
+    In the case that the server does not supply the filesize, only reading of
+    the complete file in one go is supported.
+
+    Parameters
+    ----------
+    url: str
+        Full URL of the remote resource, including the protocol
+    session: requests.Session or None
+        All calls will be made within this session, to avoid restarting
+        connections where the server allows this
+    block_size: int or None
+        The amount of read-ahead to do, in bytes. Default is 5MB, or the value
+        configured for the FileSystem creating this file
+    size: None or int
+        If given, this is the size of the file in bytes, and we don't attempt
+        to call the server to find the value.
+    kwargs: all other key-values are passed to requests calls.
+    """
+
+    def __init__(
+        self,
+        fs,
+        url,
+        session=None,
+        block_size=None,
+        mode="rb",
+        cache_type="bytes",
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        if mode != "rb":
+            raise NotImplementedError("File mode not supported")
+        self.url = url
+        self.session = session
+        self.details = {"name": url, "size": size, "type": "file"}
+        super().__init__(
+            fs=fs,
+            path=url,
+            mode=mode,
+            block_size=block_size,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def read(self, length=-1):
+        """Read bytes from file
+
+        Parameters
+        ----------
+        length: int
+            Read up to this many bytes. If negative, read all content to end of
+            file. If the server has not supplied the filesize, attempting to
+            read only part of the data will raise a ValueError.
+        """
+        if (
+            (length < 0 and self.loc == 0)  # explicit read all
+            # but not when the size is known and fits into a block anyways
+            and not (self.size is not None and self.size <= self.blocksize)
+        ):
+            self._fetch_all()
+        if self.size is None:
+            if length < 0:
+                self._fetch_all()
+        else:
+            length = min(self.size - self.loc, length)
+        return super().read(length)
+
+    def _fetch_all(self):
+        """Read whole file in one shot, without caching
+
+        This is only called when position is still at zero,
+        and read() is called without a byte-count.
+        """
+        logger.debug(f"Fetch all for {self}")
+        if not isinstance(self.cache, AllBytes):
+            r = self.session.get(self.fs.encode_url(self.url), **self.kwargs)
+            r.raise_for_status()
+            out = r.content
+            self.cache = AllBytes(size=len(out), fetcher=None, blocksize=None, data=out)
+            self.size = len(out)
+
+    def _parse_content_range(self, headers):
+        """Parse the Content-Range header"""
+        s = headers.get("Content-Range", "")
+        m = re.match(r"bytes (\d+-\d+|\*)/(\d+|\*)", s)
+        if not m:
+            return None, None, None
+
+        if m[1] == "*":
+            start = end = None
+        else:
+            start, end = [int(x) for x in m[1].split("-")]
+        total = None if m[2] == "*" else int(m[2])
+        return start, end, total
+
+    def _fetch_range(self, start, end):
+        """Download a block of data
+
+        The expectation is that the server returns only the requested bytes,
+        with HTTP code 206. If this is not the case, we first check the headers,
+        and then stream the output - if the data size is bigger than we
+        requested, an exception is raised.
+        """
+        logger.debug(f"Fetch range for {self}: {start}-{end}")
+        kwargs = self.kwargs.copy()
+        headers = kwargs.pop("headers", {}).copy()
+        headers["Range"] = f"bytes={start}-{end - 1}"
+        logger.debug("%s : %s", self.url, headers["Range"])
+        r = self.session.get(self.fs.encode_url(self.url), headers=headers, **kwargs)
+        if r.status_code == 416:
+            # range request outside file
+            return b""
+        r.raise_for_status()
+
+        # If the server has handled the range request, it should reply
+        # with status 206 (partial content). But we'll guess that a suitable
+        # Content-Range header or a Content-Length no more than the
+        # requested range also mean we have got the desired range.
+        cl = r.headers.get("Content-Length", r.headers.get("content-length", end + 1))
+        response_is_range = (
+            r.status_code == 206
+            or self._parse_content_range(r.headers)[0] == start
+            or int(cl) <= end - start
+        )
+
+        if response_is_range:
+            # partial content, as expected
+            out = r.content
+        elif start > 0:
+            raise ValueError(
+                "The HTTP server doesn't appear to support range requests. "
+                "Only reading this file from the beginning is supported. "
+                "Open with block_size=0 for a streaming file interface."
+            )
+        else:
+            # Response is not a range, but we want the start of the file,
+            # so we can read the required amount anyway.
+            cl = 0
+            out = []
+            for chunk in r.iter_content(2**20, False):
+                out.append(chunk)
+                cl += len(chunk)
+            out = b"".join(out)[: end - start]
+        return out
+
+
+magic_check = re.compile("([*[])")
+
+
+def has_magic(s):
+    match = magic_check.search(s)
+    return match is not None
+
+
+class HTTPStreamFile(AbstractBufferedFile):
+    def __init__(self, fs, url, mode="rb", session=None, **kwargs):
+        self.url = url
+        self.session = session
+        if mode != "rb":
+            raise ValueError
+        self.details = {"name": url, "size": None}
+        super().__init__(fs=fs, path=url, mode=mode, cache_type="readahead", **kwargs)
+
+        r = self.session.get(self.fs.encode_url(url), stream=True, **kwargs)
+        self.fs._raise_not_found_for_status(r, url)
+        self.it = r.iter_content(1024, False)
+        self.leftover = b""
+
+        self.r = r
+
+    def seek(self, *args, **kwargs):
+        raise ValueError("Cannot seek streaming HTTP file")
+
+    def read(self, num=-1):
+        bufs = [self.leftover]
+        leng = len(self.leftover)
+        while leng < num or num < 0:
+            try:
+                out = self.it.__next__()
+            except StopIteration:
+                break
+            if out:
+                bufs.append(out)
+            else:
+                break
+            leng += len(out)
+        out = b"".join(bufs)
+        if num >= 0:
+            self.leftover = out[num:]
+            out = out[:num]
+        else:
+            self.leftover = b""
+        self.loc += len(out)
+        return out
+
+    def close(self):
+        self.r.close()
+        self.closed = True
+
+
+def get_range(session, url, start, end, **kwargs):
+    # explicit get a range when we know it must be safe
+    kwargs = kwargs.copy()
+    headers = kwargs.pop("headers", {}).copy()
+    headers["Range"] = f"bytes={start}-{end - 1}"
+    r = session.get(url, headers=headers, **kwargs)
+    r.raise_for_status()
+    return r.content
+
+
+def _file_info(url, session, size_policy="head", **kwargs):
+    """Call HEAD on the server to get details about the file (size/checksum etc.)
+
+    Default operation is to explicitly allow redirects and use encoding
+    'identity' (no compression) to get the true size of the target.
+    """
+    logger.debug("Retrieve file size for %s", url)
+    kwargs = kwargs.copy()
+    ar = kwargs.pop("allow_redirects", True)
+    head = kwargs.get("headers", {}).copy()
+    # TODO: not allowed in JS
+    # head["Accept-Encoding"] = "identity"
+    kwargs["headers"] = head
+
+    info = {}
+    if size_policy == "head":
+        r = session.head(url, allow_redirects=ar, **kwargs)
+    elif size_policy == "get":
+        r = session.get(url, allow_redirects=ar, **kwargs)
+    else:
+        raise TypeError(f'size_policy must be "head" or "get", got {size_policy}')
+    r.raise_for_status()
+
+    # TODO:
+    #  recognise lack of 'Accept-Ranges',
+    #                 or 'Accept-Ranges': 'none' (not 'bytes')
+    #  to mean streaming only, no random access => return None
+    if "Content-Length" in r.headers:
+        info["size"] = int(r.headers["Content-Length"])
+    elif "Content-Range" in r.headers:
+        info["size"] = int(r.headers["Content-Range"].split("/")[1])
+    elif "content-length" in r.headers:
+        info["size"] = int(r.headers["content-length"])
+    elif "content-range" in r.headers:
+        info["size"] = int(r.headers["content-range"].split("/")[1])
+
+    for checksum_field in ["ETag", "Content-MD5", "Digest"]:
+        if r.headers.get(checksum_field):
+            info[checksum_field] = r.headers[checksum_field]
+
+    return info
+
+
+# importing this is enough to register it
+def register():
+    register_implementation("http", HTTPFileSystem, clobber=True)
+    register_implementation("https", HTTPFileSystem, clobber=True)
+    register_implementation("sync-http", HTTPFileSystem, clobber=True)
+    register_implementation("sync-https", HTTPFileSystem, clobber=True)
+
+
+register()
+
+
+def unregister():
+    from fsspec.implementations.http import HTTPFileSystem
+
+    register_implementation("http", HTTPFileSystem, clobber=True)
+    register_implementation("https", HTTPFileSystem, clobber=True)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/jupyter.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/jupyter.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5571ed56582170051f3b7cd903093eed4c65244
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/jupyter.py
@@ -0,0 +1,129 @@
+import base64
+import io
+import re
+
+import requests
+
+import fsspec
+
+
+class JupyterFileSystem(fsspec.AbstractFileSystem):
+    """View of the files as seen by a Jupyter server (notebook or lab)"""
+
+    protocol = ("jupyter", "jlab")
+
+    def __init__(self, url, tok=None, **kwargs):
+        """
+
+        Parameters
+        ----------
+        url : str
+            Base URL of the server, like "http://127.0.0.1:8888". May include
+            token in the string, which is given by the process when starting up
+        tok : str
+            If the token is obtained separately, can be given here
+        kwargs
+        """
+        if "?" in url:
+            if tok is None:
+                try:
+                    tok = re.findall("token=([a-z0-9]+)", url)[0]
+                except IndexError as e:
+                    raise ValueError("Could not determine token") from e
+            url = url.split("?", 1)[0]
+        self.url = url.rstrip("/") + "/api/contents"
+        self.session = requests.Session()
+        if tok:
+            self.session.headers["Authorization"] = f"token {tok}"
+
+        super().__init__(**kwargs)
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        r = self.session.get(f"{self.url}/{path}")
+        if r.status_code == 404:
+            raise FileNotFoundError(path)
+        r.raise_for_status()
+        out = r.json()
+
+        if out["type"] == "directory":
+            out = out["content"]
+        else:
+            out = [out]
+        for o in out:
+            o["name"] = o.pop("path")
+            o.pop("content")
+            if o["type"] == "notebook":
+                o["type"] = "file"
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        path = self._strip_protocol(path)
+        r = self.session.get(f"{self.url}/{path}")
+        if r.status_code == 404:
+            raise FileNotFoundError(path)
+        r.raise_for_status()
+        out = r.json()
+        if out["format"] == "text":
+            # data should be binary
+            b = out["content"].encode()
+        else:
+            b = base64.b64decode(out["content"])
+        return b[start:end]
+
+    def pipe_file(self, path, value, **_):
+        path = self._strip_protocol(path)
+        json = {
+            "name": path.rsplit("/", 1)[-1],
+            "path": path,
+            "size": len(value),
+            "content": base64.b64encode(value).decode(),
+            "format": "base64",
+            "type": "file",
+        }
+        self.session.put(f"{self.url}/{path}", json=json)
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if create_parents and "/" in path:
+            self.mkdir(path.rsplit("/", 1)[0], True)
+        json = {
+            "name": path.rsplit("/", 1)[-1],
+            "path": path,
+            "size": None,
+            "content": None,
+            "type": "directory",
+        }
+        self.session.put(f"{self.url}/{path}", json=json)
+
+    def mv(self, path1, path2, recursive=False, maxdepth=None, **kwargs):
+        if path1 == path2:
+            return
+        self.session.patch(f"{self.url}/{path1}", json={"path": path2})
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        self.session.delete(f"{self.url}/{path}")
+
+    def _open(self, path, mode="rb", **kwargs):
+        path = self._strip_protocol(path)
+        if mode == "rb":
+            data = self.cat_file(path)
+            return io.BytesIO(data)
+        else:
+            return SimpleFileWriter(self, path, mode="wb")
+
+
+class SimpleFileWriter(fsspec.spec.AbstractBufferedFile):
+    def _upload_chunk(self, final=False):
+        """Never uploads a chunk until file is done
+
+        Not suitable for large files
+        """
+        if final is False:
+            return False
+        self.buffer.seek(0)
+        data = self.buffer.read()
+        self.fs.pipe_file(self.path, data)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/libarchive.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/libarchive.py
new file mode 100644
index 0000000000000000000000000000000000000000..6f8e750002df72865d611b48022e6634f9572614
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/libarchive.py
@@ -0,0 +1,213 @@
+from contextlib import contextmanager
+from ctypes import (
+    CFUNCTYPE,
+    POINTER,
+    c_int,
+    c_longlong,
+    c_void_p,
+    cast,
+    create_string_buffer,
+)
+
+import libarchive
+import libarchive.ffi as ffi
+
+from fsspec import open_files
+from fsspec.archive import AbstractArchiveFileSystem
+from fsspec.implementations.memory import MemoryFile
+from fsspec.utils import DEFAULT_BLOCK_SIZE
+
+# Libarchive requires seekable files or memory only for certain archive
+# types. However, since we read the directory first to cache the contents
+# and also allow random access to any file, the file-like object needs
+# to be seekable no matter what.
+
+# Seek call-backs (not provided in the libarchive python wrapper)
+SEEK_CALLBACK = CFUNCTYPE(c_longlong, c_int, c_void_p, c_longlong, c_int)
+read_set_seek_callback = ffi.ffi(
+    "read_set_seek_callback", [ffi.c_archive_p, SEEK_CALLBACK], c_int, ffi.check_int
+)
+new_api = hasattr(ffi, "NO_OPEN_CB")
+
+
+@contextmanager
+def custom_reader(file, format_name="all", filter_name="all", block_size=ffi.page_size):
+    """Read an archive from a seekable file-like object.
+
+    The `file` object must support the standard `readinto` and 'seek' methods.
+    """
+    buf = create_string_buffer(block_size)
+    buf_p = cast(buf, c_void_p)
+
+    def read_func(archive_p, context, ptrptr):
+        # readinto the buffer, returns number of bytes read
+        length = file.readinto(buf)
+        # write the address of the buffer into the pointer
+        ptrptr = cast(ptrptr, POINTER(c_void_p))
+        ptrptr[0] = buf_p
+        # tell libarchive how much data was written into the buffer
+        return length
+
+    def seek_func(archive_p, context, offset, whence):
+        file.seek(offset, whence)
+        # tell libarchvie the current position
+        return file.tell()
+
+    read_cb = ffi.READ_CALLBACK(read_func)
+    seek_cb = SEEK_CALLBACK(seek_func)
+
+    if new_api:
+        open_cb = ffi.NO_OPEN_CB
+        close_cb = ffi.NO_CLOSE_CB
+    else:
+        open_cb = libarchive.read.OPEN_CALLBACK(ffi.VOID_CB)
+        close_cb = libarchive.read.CLOSE_CALLBACK(ffi.VOID_CB)
+
+    with libarchive.read.new_archive_read(format_name, filter_name) as archive_p:
+        read_set_seek_callback(archive_p, seek_cb)
+        ffi.read_open(archive_p, None, open_cb, read_cb, close_cb)
+        yield libarchive.read.ArchiveRead(archive_p)
+
+
+class LibArchiveFileSystem(AbstractArchiveFileSystem):
+    """Compressed archives as a file-system (read-only)
+
+    Supports the following formats:
+    tar, pax , cpio, ISO9660, zip, mtree, shar, ar, raw, xar, lha/lzh, rar
+    Microsoft CAB, 7-Zip, WARC
+
+    See the libarchive documentation for further restrictions.
+    https://www.libarchive.org/
+
+    Keeps file object open while instance lives. It only works in seekable
+    file-like objects. In case the filesystem does not support this kind of
+    file object, it is recommended to cache locally.
+
+    This class is pickleable, but not necessarily thread-safe (depends on the
+    platform). See libarchive documentation for details.
+    """
+
+    root_marker = ""
+    protocol = "libarchive"
+    cachable = False
+
+    def __init__(
+        self,
+        fo="",
+        mode="r",
+        target_protocol=None,
+        target_options=None,
+        block_size=DEFAULT_BLOCK_SIZE,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo: str or file-like
+            Contains ZIP, and must exist. If a str, will fetch file using
+            :meth:`~fsspec.open_files`, which must return one file exactly.
+        mode: str
+            Currently, only 'r' accepted
+        target_protocol: str (optional)
+            If ``fo`` is a string, this value can be used to override the
+            FS protocol inferred from a URL
+        target_options: dict (optional)
+            Kwargs passed when instantiating the target FS, if ``fo`` is
+            a string.
+        """
+        super().__init__(self, **kwargs)
+        if mode != "r":
+            raise ValueError("Only read from archive files accepted")
+        if isinstance(fo, str):
+            files = open_files(fo, protocol=target_protocol, **(target_options or {}))
+            if len(files) != 1:
+                raise ValueError(
+                    f'Path "{fo}" did not resolve to exactly one file: "{files}"'
+                )
+            fo = files[0]
+        self.of = fo
+        self.fo = fo.__enter__()  # the whole instance is a context
+        self.block_size = block_size
+        self.dir_cache = None
+
+    @contextmanager
+    def _open_archive(self):
+        self.fo.seek(0)
+        with custom_reader(self.fo, block_size=self.block_size) as arc:
+            yield arc
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def _get_dirs(self):
+        fields = {
+            "name": "pathname",
+            "size": "size",
+            "created": "ctime",
+            "mode": "mode",
+            "uid": "uid",
+            "gid": "gid",
+            "mtime": "mtime",
+        }
+
+        if self.dir_cache is not None:
+            return
+
+        self.dir_cache = {}
+        list_names = []
+        with self._open_archive() as arc:
+            for entry in arc:
+                if not entry.isdir and not entry.isfile:
+                    # Skip symbolic links, fifo entries, etc.
+                    continue
+                self.dir_cache.update(
+                    {
+                        dirname: {"name": dirname, "size": 0, "type": "directory"}
+                        for dirname in self._all_dirnames(set(entry.name))
+                    }
+                )
+                f = {key: getattr(entry, fields[key]) for key in fields}
+                f["type"] = "directory" if entry.isdir else "file"
+                list_names.append(entry.name)
+
+                self.dir_cache[f["name"]] = f
+        # libarchive does not seem to return an entry for the directories (at least
+        # not in all formats), so get the directories names from the files names
+        self.dir_cache.update(
+            {
+                dirname: {"name": dirname, "size": 0, "type": "directory"}
+                for dirname in self._all_dirnames(list_names)
+            }
+        )
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if mode != "rb":
+            raise NotImplementedError
+
+        data = b""
+        with self._open_archive() as arc:
+            for entry in arc:
+                if entry.pathname != path:
+                    continue
+
+                if entry.size == 0:
+                    # empty file, so there are no blocks
+                    break
+
+                for block in entry.get_blocks(entry.size):
+                    data = block
+                    break
+                else:
+                    raise ValueError
+        return MemoryFile(fs=self, path=path, data=data)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/local.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/local.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec2dd42c8fd6858f47e92fd05312fe6e96f199c5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/local.py
@@ -0,0 +1,525 @@
+import datetime
+import io
+import logging
+import os
+import os.path as osp
+import shutil
+import stat
+import tempfile
+from functools import lru_cache
+
+from fsspec.compression import compr
+from fsspec.core import get_compression
+from fsspec.utils import isfilelike, stringify_path
+
+from ..spec import AbstractFileSystem
+
+logger = logging.getLogger("fsspec.local")
+
+
+class LocalFileSystem(AbstractFileSystem):
+    """Interface to files on local storage
+
+    Parameters
+    ----------
+    auto_mkdir: bool
+        Whether, when opening a file, the directory containing it should
+        be created (if it doesn't already exist). This is assumed by pyarrow
+        code.
+    """
+
+    root_marker = "/"
+    protocol = "file", "local"
+    local_file = True
+
+    def __init__(self, auto_mkdir=False, **kwargs):
+        super().__init__(**kwargs)
+        self.auto_mkdir = auto_mkdir
+
+    @property
+    def fsid(self):
+        return "local"
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if self.exists(path):
+            raise FileExistsError(path)
+        if create_parents:
+            self.makedirs(path, exist_ok=True)
+        else:
+            os.mkdir(path, **kwargs)
+
+    def makedirs(self, path, exist_ok=False):
+        path = self._strip_protocol(path)
+        os.makedirs(path, exist_ok=exist_ok)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        os.rmdir(path)
+
+    def ls(self, path, detail=False, **kwargs):
+        path = self._strip_protocol(path)
+        path_info = self.info(path)
+        infos = []
+        if path_info["type"] == "directory":
+            with os.scandir(path) as it:
+                for f in it:
+                    try:
+                        # Only get the info if requested since it is a bit expensive (the stat call inside)
+                        # The strip_protocol is also used in info() and calls make_path_posix to always return posix paths
+                        info = self.info(f) if detail else self._strip_protocol(f.path)
+                        infos.append(info)
+                    except FileNotFoundError:
+                        pass
+        else:
+            infos = [path_info] if detail else [path_info["name"]]
+
+        return infos
+
+    def info(self, path, **kwargs):
+        if isinstance(path, os.DirEntry):
+            # scandir DirEntry
+            out = path.stat(follow_symlinks=False)
+            link = path.is_symlink()
+            if path.is_dir(follow_symlinks=False):
+                t = "directory"
+            elif path.is_file(follow_symlinks=False):
+                t = "file"
+            else:
+                t = "other"
+
+            size = out.st_size
+            if link:
+                try:
+                    out2 = path.stat(follow_symlinks=True)
+                    size = out2.st_size
+                except OSError:
+                    size = 0
+            path = self._strip_protocol(path.path)
+        else:
+            # str or path-like
+            path = self._strip_protocol(path)
+            out = os.stat(path, follow_symlinks=False)
+            link = stat.S_ISLNK(out.st_mode)
+            if link:
+                out = os.stat(path, follow_symlinks=True)
+            size = out.st_size
+            if stat.S_ISDIR(out.st_mode):
+                t = "directory"
+            elif stat.S_ISREG(out.st_mode):
+                t = "file"
+            else:
+                t = "other"
+
+        # Check for the 'st_birthtime' attribute, which is not always present; fallback to st_ctime
+        created_time = getattr(out, "st_birthtime", out.st_ctime)
+
+        result = {
+            "name": path,
+            "size": size,
+            "type": t,
+            "created": created_time,
+            "islink": link,
+        }
+        for field in ["mode", "uid", "gid", "mtime", "ino", "nlink"]:
+            result[field] = getattr(out, f"st_{field}")
+        if link:
+            result["destination"] = os.readlink(path)
+        return result
+
+    def lexists(self, path, **kwargs):
+        return osp.lexists(path)
+
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path2), exist_ok=True)
+        if self.isfile(path1):
+            shutil.copyfile(path1, path2)
+        elif self.isdir(path1):
+            self.mkdirs(path2, exist_ok=True)
+        else:
+            raise FileNotFoundError(path1)
+
+    def isfile(self, path):
+        path = self._strip_protocol(path)
+        return os.path.isfile(path)
+
+    def isdir(self, path):
+        path = self._strip_protocol(path)
+        return os.path.isdir(path)
+
+    def get_file(self, path1, path2, callback=None, **kwargs):
+        if isfilelike(path2):
+            with open(path1, "rb") as f:
+                shutil.copyfileobj(f, path2)
+        else:
+            return self.cp_file(path1, path2, **kwargs)
+
+    def put_file(self, path1, path2, callback=None, **kwargs):
+        return self.cp_file(path1, path2, **kwargs)
+
+    def mv(self, path1, path2, recursive: bool = True, **kwargs):
+        """Move files/directories
+        For the specific case of local, all ops on directories are recursive and
+        the recursive= kwarg is ignored.
+        """
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path2), exist_ok=True)
+
+        shutil.move(path1, path2)
+
+    def link(self, src, dst, **kwargs):
+        src = self._strip_protocol(src)
+        dst = self._strip_protocol(dst)
+        os.link(src, dst, **kwargs)
+
+    def symlink(self, src, dst, **kwargs):
+        src = self._strip_protocol(src)
+        dst = self._strip_protocol(dst)
+        os.symlink(src, dst, **kwargs)
+
+    def islink(self, path) -> bool:
+        return os.path.islink(self._strip_protocol(path))
+
+    def rm_file(self, path):
+        os.remove(self._strip_protocol(path))
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        if not isinstance(path, list):
+            path = [path]
+
+        for p in path:
+            p = self._strip_protocol(p)
+            if self.isdir(p) and not self.islink(p):
+                if not recursive:
+                    raise ValueError("Cannot delete directory, set recursive=True")
+                if osp.abspath(p) == os.getcwd():
+                    raise ValueError("Cannot delete current working directory")
+                shutil.rmtree(p)
+            else:
+                os.remove(p)
+
+    def unstrip_protocol(self, name):
+        protocol = self.protocol if isinstance(self.protocol, str) else self.protocol[0]
+        name = self._strip_protocol(name)  # normalise for local/win/...
+        return f"{protocol}://{name}"
+
+    def _open(self, path, mode="rb", block_size=None, **kwargs):
+        path = self._strip_protocol(path)
+        if self.auto_mkdir and ("w" in mode or "x" in mode or "a" in mode):
+            self.makedirs(self._parent(path), exist_ok=True)
+        return LocalFileOpener(path, mode, fs=self, **kwargs)
+
+    def touch(self, path, truncate=True, **kwargs):
+        path = self._strip_protocol(path)
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path), exist_ok=True)
+        if self.exists(path):
+            os.utime(path, None)
+        else:
+            open(path, "a").close()
+        if truncate:
+            os.truncate(path, 0)
+
+    def created(self, path):
+        info = self.info(path=path)
+        return datetime.datetime.fromtimestamp(
+            info["created"], tz=datetime.timezone.utc
+        )
+
+    def modified(self, path):
+        info = self.info(path=path)
+        return datetime.datetime.fromtimestamp(info["mtime"], tz=datetime.timezone.utc)
+
+    @classmethod
+    def _parent(cls, path):
+        path = cls._strip_protocol(path)
+        if os.sep == "/":
+            # posix native
+            return path.rsplit("/", 1)[0] or "/"
+        else:
+            # NT
+            path_ = path.rsplit("/", 1)[0]
+            if len(path_) <= 3:
+                if path_[1:2] == ":":
+                    # nt root (something like c:/)
+                    return path_[0] + ":/"
+            # More cases may be required here
+            return path_
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        path = stringify_path(path)
+        protos = (cls.protocol,) if isinstance(cls.protocol, str) else cls.protocol
+        prefixes = (protocol + sep for protocol in protos for sep in ("://", ":"))
+        for prefix in prefixes:
+            if path.startswith(prefix):
+                path = path.removeprefix(prefix)
+                break
+
+        path = make_path_posix(path)
+        if os.sep != "/":
+            # This code-path is a stripped down version of
+            # > drive, path = ntpath.splitdrive(path)
+            if path[1:2] == ":":
+                # Absolute drive-letter path, e.g. X:\Windows
+                # Relative path with drive, e.g. X:Windows
+                drive, path = path[:2], path[2:]
+            elif path[:2] == "//":
+                # UNC drives, e.g. \\server\share or \\?\UNC\server\share
+                # Device drives, e.g. \\.\device or \\?\device
+                if (index1 := path.find("/", 2)) == -1 or (
+                    index2 := path.find("/", index1 + 1)
+                ) == -1:
+                    drive, path = path, ""
+                else:
+                    drive, path = path[:index2], path[index2:]
+            else:
+                # Relative path, e.g. Windows
+                drive = ""
+
+            path = path.rstrip("/") or cls.root_marker
+            return drive + path
+
+        else:
+            return path.rstrip("/") or cls.root_marker
+
+    def _isfilestore(self):
+        # Inheriting from DaskFileSystem makes this False (S3, etc. were)
+        # the original motivation. But we are a posix-like file system.
+        # See https://github.com/dask/dask/issues/5526
+        return True
+
+    def chmod(self, path, mode):
+        path = stringify_path(path)
+        return os.chmod(path, mode)
+
+
+def make_path_posix(path):
+    """Make path generic and absolute for current OS"""
+    if not isinstance(path, str):
+        if isinstance(path, (list, set, tuple)):
+            return type(path)(make_path_posix(p) for p in path)
+        else:
+            path = stringify_path(path)
+            if not isinstance(path, str):
+                raise TypeError(f"could not convert {path!r} to string")
+    if os.sep == "/":
+        # Native posix
+        if path.startswith("/"):
+            # most common fast case for posix
+            return path
+        elif path.startswith("~"):
+            return osp.expanduser(path)
+        elif path.startswith("./"):
+            path = path[2:]
+        elif path == ".":
+            path = ""
+        return f"{os.getcwd()}/{path}"
+    else:
+        # NT handling
+        if path[0:1] == "/" and path[2:3] == ":":
+            # path is like "/c:/local/path"
+            path = path[1:]
+        if path[1:2] == ":":
+            # windows full path like "C:\\local\\path"
+            if len(path) == 2 or (len(path) == 3 and path[2] in "/\\"):
+                # nt root (something like c:/). A three-character "c:x" is not a
+                # root: it names "x" relative to that drive, so it falls through
+                # instead of being collapsed to the drive root.
+                return path[0] + ":/"
+            path = path.replace("\\", "/")
+            return path
+        elif path[0:1] == "~":
+            return make_path_posix(osp.expanduser(path))
+        elif path.startswith(("\\\\", "//")):
+            # windows UNC/DFS-style paths
+            return "//" + path[2:].replace("\\", "/")
+        elif path.startswith(("\\", "/")):
+            # windows relative path with root
+            path = path.replace("\\", "/")
+            return f"{osp.splitdrive(os.getcwd())[0]}{path}"
+        else:
+            path = path.replace("\\", "/")
+            if path.startswith("./"):
+                path = path[2:]
+            elif path == ".":
+                path = ""
+            return f"{make_path_posix(os.getcwd())}/{path}"
+
+
+def trailing_sep(path):
+    """Return True if the path ends with a path separator.
+
+    A forward slash is always considered a path separator, even on Operating
+    Systems that normally use a backslash.
+    """
+    # TODO: if all incoming paths were posix-compliant then separator would
+    # always be a forward slash, simplifying this function.
+    # See https://github.com/fsspec/filesystem_spec/pull/1250
+    return path.endswith(os.sep) or (os.altsep is not None and path.endswith(os.altsep))
+
+
+@lru_cache(maxsize=1)
+def get_umask(mask: int = 0o666) -> int:
+    """Get the current umask.
+
+    Follows https://stackoverflow.com/a/44130549 to get the umask.
+    Temporarily sets the umask to the given value, and then resets it to the
+    original value.
+    """
+    value = os.umask(mask)
+    os.umask(value)
+    return value
+
+
+class LocalFileOpener(io.IOBase):
+    def __init__(
+        self, path, mode, autocommit=True, fs=None, compression=None, **kwargs
+    ):
+        logger.debug("open file: %s", path)
+        self.path = path
+        self.mode = mode
+        self.fs = fs
+        self.f = None
+        self.autocommit = autocommit
+        self.compression = get_compression(path, compression)
+        self.blocksize = io.DEFAULT_BUFFER_SIZE
+        self._open()
+
+    def _open(self):
+        if self.f is None or self.f.closed:
+            if self.autocommit or "w" not in self.mode:
+                self.f = open(self.path, mode=self.mode)
+                if self.compression:
+                    compress = compr[self.compression]
+                    self.f = compress(self.f, mode=self.mode)
+            else:
+                # TODO: check if path is writable?
+                i, name = tempfile.mkstemp()
+                os.close(i)  # we want normal open and normal buffered file
+                self.temp = name
+                self.f = open(name, mode=self.mode)
+            if "w" not in self.mode:
+                self.size = self.f.seek(0, 2)
+                self.f.seek(0)
+                self.f.size = self.size
+
+    def _fetch_range(self, start, end):
+        # probably only used by cached FS
+        if "r" not in self.mode:
+            raise ValueError
+        self._open()
+        self.f.seek(start)
+        return self.f.read(end - start)
+
+    def __setstate__(self, state):
+        self.f = None
+        loc = state.pop("loc", None)
+        self.__dict__.update(state)
+        if "r" in state["mode"]:
+            self.f = None
+            self._open()
+            self.f.seek(loc)
+
+    def __getstate__(self):
+        d = self.__dict__.copy()
+        d.pop("f")
+        if "r" in self.mode:
+            d["loc"] = self.f.tell()
+        else:
+            if not self.f.closed:
+                raise ValueError("Cannot serialise open write-mode local file")
+        return d
+
+    def commit(self):
+        if self.autocommit:
+            raise RuntimeError("Can only commit if not already set to autocommit")
+        if not self.f.closed:
+            # a compression wrapper (e.g., GzipFile) does not close the file
+            # object it was given, so buffered bytes and any trailer may still
+            # be pending here. Windows also refuses to rename an open file.
+            self.f.close()
+        try:
+            shutil.move(self.temp, self.path)
+        except PermissionError as e:
+            # shutil.move raises PermissionError if os.rename
+            # and the default copy2 fallback with shutil.copystats fail.
+            # The file should be there nonetheless, but without copied permissions.
+            # If it doesn't exist, there was no permission to create the file.
+            if not os.path.exists(self.path):
+                raise e
+        else:
+            # If PermissionError is not raised, permissions can be set.
+            try:
+                mask = 0o666
+                os.chmod(self.path, mask & ~get_umask(mask))
+            except RuntimeError:
+                pass
+
+    def discard(self):
+        if self.autocommit:
+            raise RuntimeError("Cannot discard if set to autocommit")
+        os.remove(self.temp)
+
+    def readable(self) -> bool:
+        return True
+
+    def writable(self) -> bool:
+        return "r" not in self.mode
+
+    def read(self, *args, **kwargs):
+        return self.f.read(*args, **kwargs)
+
+    def write(self, *args, **kwargs):
+        return self.f.write(*args, **kwargs)
+
+    def tell(self, *args, **kwargs):
+        return self.f.tell(*args, **kwargs)
+
+    def seek(self, *args, **kwargs):
+        return self.f.seek(*args, **kwargs)
+
+    def seekable(self, *args, **kwargs):
+        return self.f.seekable(*args, **kwargs)
+
+    def readline(self, *args, **kwargs):
+        return self.f.readline(*args, **kwargs)
+
+    def readlines(self, *args, **kwargs):
+        return self.f.readlines(*args, **kwargs)
+
+    def close(self):
+        return self.f.close()
+
+    def truncate(self, size=None) -> int:
+        return self.f.truncate(size)
+
+    @property
+    def closed(self):
+        return self.f.closed
+
+    def fileno(self):
+        return self.raw.fileno()
+
+    def flush(self) -> None:
+        self.f.flush()
+
+    def __iter__(self):
+        return self.f.__iter__()
+
+    def __getattr__(self, item):
+        return getattr(self.f, item)
+
+    def __enter__(self):
+        self._incontext = True
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._incontext = False
+        self.f.__exit__(exc_type, exc_value, traceback)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/memory.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/memory.py
new file mode 100644
index 0000000000000000000000000000000000000000..6d846ab91e433b1b9096b8537aac9cee1178244f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/memory.py
@@ -0,0 +1,438 @@
+from __future__ import annotations
+
+import logging
+from datetime import datetime, timezone
+from errno import ENOTEMPTY
+from io import BytesIO
+from pathlib import PurePath, PureWindowsPath
+from typing import Any
+
+from fsspec import AbstractFileSystem
+from fsspec.implementations.local import LocalFileSystem
+from fsspec.utils import stringify_path, tokenize
+
+logger = logging.getLogger("fsspec.memoryfs")
+
+
+class MemoryFileSystem(AbstractFileSystem):
+    """A filesystem based on a dict of BytesIO objects
+
+    By default, instances share a global in-memory filesystem. Pass
+    ``global_store=False, skip_instance_cache=True`` to create a new instance
+    with an independent store instead.
+    """
+
+    store: dict[str, Any] = {}  # shared by default
+    pseudo_dirs = [""]  # shared by default
+    protocol = "memory"
+    root_marker = "/"
+
+    def __init__(self, *args, global_store=True, **kwargs):
+        """Create a memory filesystem.
+
+        Parameters
+        ----------
+        global_store: bool
+            Share files and directories with other default instances. If False,
+            each instance starts with an empty, independent store. The normal
+            instance cache still applies; pass ``skip_instance_cache=True``
+            to create a new instance on every call. Pickling an
+            independent filesystem copies its files and directories; pickling a
+            global filesystem retains the reference to the global store.
+        """
+        super().__init__(*args, **kwargs)
+        self.global_store = global_store
+        if not global_store:
+            self.store = {}
+            self.pseudo_dirs = [""]
+
+    @property
+    def _fs_token(self):
+        if self.global_store:
+            return super()._fs_token
+        return tokenize(super()._fs_token, id(self))
+
+    def __reduce__(self):
+        reduced = super().__reduce__()
+        if self.global_store:
+            return reduced
+        factory, (cls, args, kwargs) = reduced
+        # Restore into a new instance even when the source is cached.
+        kwargs = {**kwargs, "skip_instance_cache": True}
+        # Pickle's memo preserves the cycle through each MemoryFile.fs.
+        return (
+            factory,
+            (cls, args, kwargs),
+            {"store": self.store, "pseudo_dirs": self.pseudo_dirs},
+        )
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        if isinstance(path, PurePath):
+            if isinstance(path, PureWindowsPath):
+                return LocalFileSystem._strip_protocol(path)
+            else:
+                path = stringify_path(path)
+
+        path = path.removeprefix("memory://")
+        if "::" in path or "://" in path:
+            return path.rstrip("/")
+        path = path.lstrip("/").rstrip("/")
+        return "/" + path if path else ""
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        # The base implementation calls ls() once per directory, and each ls()
+        # scans the whole store, giving O(n_dirs * n_entries) behaviour
+        # for a tree. Since the store is a flat mapping of every path, the same
+        # result can be produced with a single pass over it.
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+        path = self._strip_protocol(path)
+        if path in self.store:
+            # path is itself a file
+            if not detail:
+                return [path]
+            filelike = self.store[path]
+            return {
+                path: {
+                    "name": path,
+                    "size": filelike.size,
+                    "type": "file",
+                    "created": filelike.created.timestamp(),
+                }
+            }
+
+        # Uniform prefix so that the search root "" (the filesystem root) and a
+        # nested path are handled the same way; rel depth is rel.count("/") + 1.
+        prefix = path + "/" if path else "/"
+        out = {}
+        dirs = {}
+
+        def add_ancestor_dirs(name):
+            # Register every directory implied between ``path`` and ``name`` that
+            # is within maxdepth, mirroring how walk() surfaces implied dirs.
+            idx = name.rfind("/")
+            while idx > len(path):
+                parent = name[:idx]
+                if parent in dirs:
+                    break
+                rel = parent[len(prefix) :]
+                if maxdepth is None or rel.count("/") + 1 <= maxdepth:
+                    dirs[parent] = {"name": parent, "size": 0, "type": "directory"}
+                idx = parent.rfind("/")
+
+        # `store` may be shared by multiple MemoryFileSystem instances, so iterate a
+        # snapshot: a concurrent create/delete would otherwise raise
+        # "dictionary changed size during iteration". ls() does the same.
+        for name, filelike in tuple(self.store.items()):
+            if not name.startswith(prefix):
+                continue
+            rel = name[len(prefix) :]
+            if withdirs:
+                add_ancestor_dirs(name)
+            if maxdepth is not None and rel.count("/") + 1 > maxdepth:
+                continue
+            out[name] = {
+                "name": name,
+                "size": filelike.size,
+                "type": "file",
+                "created": filelike.created.timestamp(),
+            }
+
+        if withdirs:
+            # Explicitly-created (possibly empty) directories live in pseudo_dirs.
+            for pdir in self.pseudo_dirs:
+                if pdir and pdir.startswith(prefix):
+                    add_ancestor_dirs(pdir + "/")
+            out.update(dirs)
+            # Mirror the base find(): include the search root itself when it is
+            # a directory (needed for posix glob compliance).
+            if path != "" and self.isdir(path):
+                out[path] = self.info(path)
+
+        names = sorted(out)
+        return {name: out[name] for name in names} if detail else names
+
+    def ls(self, path, detail=True, **kwargs):
+        path = self._strip_protocol(path)
+        if path in self.store:
+            # there is a key with this exact name
+            if not detail:
+                return [path]
+            return [
+                {
+                    "name": path,
+                    "size": self.store[path].size,
+                    "type": "file",
+                    "created": self.store[path].created.timestamp(),
+                }
+            ]
+        paths = set()
+        starter = path + "/"
+        out = []
+        for p2 in tuple(self.store):
+            if p2.startswith(starter):
+                if "/" not in p2[len(starter) :]:
+                    # exact child
+                    out.append(
+                        {
+                            "name": p2,
+                            "size": self.store[p2].size,
+                            "type": "file",
+                            "created": self.store[p2].created.timestamp(),
+                        }
+                    )
+                elif len(p2) > len(starter):
+                    # implied child directory
+                    ppath = starter + p2[len(starter) :].split("/", 1)[0]
+                    if ppath not in paths:
+                        out = out or []
+                        out.append(
+                            {
+                                "name": ppath,
+                                "size": 0,
+                                "type": "directory",
+                            }
+                        )
+                        paths.add(ppath)
+        for p2 in self.pseudo_dirs:
+            if p2.startswith(starter):
+                if "/" not in p2[len(starter) :]:
+                    # exact child pdir
+                    if p2 not in paths:
+                        out.append({"name": p2, "size": 0, "type": "directory"})
+                        paths.add(p2)
+                else:
+                    # directory implied by deeper pdir
+                    ppath = starter + p2[len(starter) :].split("/", 1)[0]
+                    if ppath not in paths:
+                        out.append({"name": ppath, "size": 0, "type": "directory"})
+                        paths.add(ppath)
+        if not out:
+            if path in self.pseudo_dirs:
+                # empty dir
+                return []
+            raise FileNotFoundError(path)
+        if detail:
+            return out
+        return sorted([f["name"] for f in out])
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        path = self._strip_protocol(path)
+        if path in self.store or path in self.pseudo_dirs:
+            raise FileExistsError(path)
+        if self._parent(path).strip("/") and self.isfile(self._parent(path)):
+            raise NotADirectoryError(self._parent(path))
+        if create_parents and self._parent(path).strip("/"):
+            try:
+                self.mkdir(self._parent(path), create_parents, **kwargs)
+            except FileExistsError:
+                pass
+        if path and path not in self.pseudo_dirs:
+            self.pseudo_dirs.append(path)
+
+    def makedirs(self, path, exist_ok=False):
+        try:
+            self.mkdir(path, create_parents=True)
+        except FileExistsError:
+            if not exist_ok:
+                raise
+
+    def pipe_file(self, path, value, mode="overwrite", **kwargs):
+        """Set the bytes of given file
+
+        Avoids copies of the data if possible
+        """
+        mode = "xb" if mode == "create" else "wb"
+        self.open(path, mode=mode, data=value)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        if path == "":
+            # silently avoid deleting FS root
+            return
+        if path in self.pseudo_dirs:
+            if not self.ls(path):
+                self.pseudo_dirs.remove(path)
+            else:
+                raise OSError(ENOTEMPTY, "Directory not empty", path)
+        else:
+            raise FileNotFoundError(path)
+
+    def info(self, path, **kwargs):
+        logger.debug("info: %s", path)
+        path = self._strip_protocol(path)
+        if path in self.pseudo_dirs or any(
+            p.startswith(path + "/") for p in list(self.store) + self.pseudo_dirs
+        ):
+            return {
+                "name": path,
+                "size": 0,
+                "type": "directory",
+            }
+        elif path in self.store:
+            filelike = self.store[path]
+            return {
+                "name": path,
+                "size": filelike.size,
+                "type": "file",
+                "created": getattr(filelike, "created", None),
+            }
+        else:
+            raise FileNotFoundError(path)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if "x" in mode and self.exists(path):
+            raise FileExistsError
+        if path in self.pseudo_dirs:
+            raise IsADirectoryError(path)
+        parent = path
+        while len(parent) > 1:
+            parent = self._parent(parent)
+            if self.isfile(parent):
+                raise FileExistsError(parent)
+        if mode in ["rb", "ab", "r+b", "a+b"]:
+            if path in self.store:
+                f = self.store[path]
+                if "a" in mode:
+                    # position at the end of file
+                    f.seek(0, 2)
+                else:
+                    # position at the beginning of file
+                    f.seek(0)
+                return f
+            elif "a" in mode:
+                # append modes create the file if it does not exist, matching
+                # builtin open() and LocalFileSystem
+                m = MemoryFile(self, path, kwargs.get("data"))
+                if not self._intrans:
+                    m.commit()
+                # position at the end of file, like the existing-file path above
+                m.seek(0, 2)
+                return m
+            else:
+                raise FileNotFoundError(path)
+        elif mode in {"wb", "w+b", "xb", "x+b"}:
+            if "x" in mode and self.exists(path):
+                raise FileExistsError
+            m = MemoryFile(self, path, kwargs.get("data"))
+            if not self._intrans:
+                m.commit()
+            return m
+        else:
+            name = self.__class__.__name__
+            raise ValueError(f"unsupported file mode for {name}: {mode!r}")
+
+    def cp_file(self, path1, path2, **kwargs):
+        path1 = self._strip_protocol(path1)
+        path2 = self._strip_protocol(path2)
+        if self.isfile(path1):
+            self.store[path2] = MemoryFile(
+                self, path2, self.store[path1].getvalue()
+            )  # implicit copy
+        elif self.isdir(path1):
+            if path2 not in self.pseudo_dirs:
+                self.pseudo_dirs.append(path2)
+        else:
+            raise FileNotFoundError(path1)
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        logger.debug("cat: %s", path)
+        path = self._strip_protocol(path)
+        try:
+            return bytes(self.store[path].getbuffer()[start:end])
+        except KeyError as e:
+            raise FileNotFoundError(path) from e
+
+    def _rm(self, path):
+        path = self._strip_protocol(path)
+        try:
+            del self.store[path]
+        except KeyError as e:
+            raise FileNotFoundError(path) from e
+
+    def modified(self, path):
+        path = self._strip_protocol(path)
+        try:
+            return self.store[path].modified
+        except KeyError as e:
+            raise FileNotFoundError(path) from e
+
+    def created(self, path):
+        path = self._strip_protocol(path)
+        try:
+            return self.store[path].created
+        except KeyError as e:
+            raise FileNotFoundError(path) from e
+
+    def isfile(self, path):
+        path = self._strip_protocol(path)
+        return path in self.store
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        if isinstance(path, str):
+            path = self._strip_protocol(path)
+        else:
+            path = [self._strip_protocol(p) for p in path]
+        paths = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        # A non-recursive expand keeps a literal path whether or not it exists,
+        # so record what exists before anything is deleted.
+        existed = {p for p in paths if self.exists(p)}
+        for p in reversed(paths):
+            if self.isfile(p):
+                self.rm_file(p)
+            elif not self.exists(p):
+                # A directory that is not in self.pseudo_dirs only exists while it
+                # has files under it, so deleting those files earlier in this loop
+                # makes it vanish. That is expected; a path that never existed is
+                # not, and raises like rm_file and the other filesystems do.
+                if p not in existed:
+                    raise FileNotFoundError(p)
+                continue
+            else:
+                self.rmdir(p)
+
+
+class MemoryFile(BytesIO):
+    """A BytesIO which can't close and works as a context manager
+
+    Can initialise with data. Each path should only be active once at any moment.
+
+    No need to provide fs, path if auto-committing (default)
+    """
+
+    def __init__(self, fs=None, path=None, data=None):
+        logger.debug("open file %s", path)
+        self.fs = fs
+        self.path = path
+        self.created = datetime.now(tz=timezone.utc)
+        self.modified = datetime.now(tz=timezone.utc)
+        if data:
+            super().__init__(data)
+            self.seek(0)
+
+    @property
+    def size(self):
+        return self.getbuffer().nbytes
+
+    def __enter__(self):
+        return self
+
+    def close(self):
+        pass
+
+    def discard(self):
+        pass
+
+    def commit(self):
+        self.fs.store[self.path] = self
+        self.modified = datetime.now(tz=timezone.utc)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/reference.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/reference.py
new file mode 100644
index 0000000000000000000000000000000000000000..0895e563a9503e17d0317e75099b589767e0fe8f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/reference.py
@@ -0,0 +1,1358 @@
+import base64
+import collections
+import io
+import itertools
+import logging
+import math
+import os
+from functools import lru_cache
+from itertools import chain
+from typing import TYPE_CHECKING, Literal
+
+import fsspec.core
+from fsspec.spec import AbstractBufferedFile
+
+try:
+    import ujson as json
+except ImportError:
+    if not TYPE_CHECKING:
+        import json
+
+from fsspec.asyn import AsyncFileSystem
+from fsspec.callbacks import DEFAULT_CALLBACK
+from fsspec.core import filesystem, open, split_protocol
+from fsspec.implementations.asyn_wrapper import AsyncFileSystemWrapper
+from fsspec.utils import (
+    check_contained,
+    isfilelike,
+    merge_offset_ranges,
+    other_paths,
+)
+
+logger = logging.getLogger("fsspec.reference")
+
+
+class ReferenceNotReachable(RuntimeError):
+    def __init__(self, reference, target, *args):
+        super().__init__(*args)
+        self.reference = reference
+        self.target = target
+
+    def __str__(self):
+        return f'Reference "{self.reference}" failed to fetch target {self.target}'
+
+
+def _first(d):
+    return next(iter(d.values()))
+
+
+def _prot_in_references(path, references):
+    ref = references.get(path)
+    if isinstance(ref, (list, tuple)) and isinstance(ref[0], str):
+        return split_protocol(ref[0])[0] if ref[0] else ref[0]
+
+
+def _protocol_groups(paths, references):
+    if isinstance(paths, str):
+        return {_prot_in_references(paths, references): [paths]}
+    out = {}
+    for path in paths:
+        protocol = _prot_in_references(path, references)
+        out.setdefault(protocol, []).append(path)
+    return out
+
+
+class RefsValuesView(collections.abc.ValuesView):
+    def __iter__(self):
+        for val in self._mapping.zmetadata.values():
+            yield json.dumps(val).encode()
+        yield from self._mapping._items.values()
+        for field in self._mapping.listdir():
+            chunk_sizes = self._mapping._get_chunk_sizes(field)
+            if len(chunk_sizes) == 0:
+                yield self._mapping[field + "/0"]
+                continue
+            yield from self._mapping._generate_all_records(field)
+
+
+class RefsItemsView(collections.abc.ItemsView):
+    def __iter__(self):
+        return zip(self._mapping.keys(), self._mapping.values())
+
+
+def ravel_multi_index(idx, sizes):
+    val = 0
+    mult = 1
+    for i, s in zip(idx[::-1], sizes[::-1]):
+        val += i * mult
+        mult *= s
+    return val
+
+
+class LazyReferenceMapper(collections.abc.MutableMapping):
+    """This interface can be used to read/write references from Parquet stores.
+    It is not intended for other types of references.
+    It can be used with Kerchunk's MultiZarrToZarr method to combine
+    references into a parquet store.
+    Examples of this use-case can be found here:
+    https://fsspec.github.io/kerchunk/advanced.html?highlight=parquet#parquet-storage"""
+
+    # import is class level to prevent numpy dep requirement for fsspec
+    @property
+    def np(self):
+        import numpy as np
+
+        return np
+
+    @property
+    def pd(self):
+        import pandas as pd
+
+        return pd
+
+    def __init__(
+        self,
+        root,
+        fs=None,
+        out_root=None,
+        cache_size=128,
+        categorical_threshold=10,
+        engine: Literal["fastparquet", "pyarrow"] = "fastparquet",
+    ):
+        """
+
+        This instance will be writable, storing changes in memory until full partitions
+        are accumulated or .flush() is called.
+
+        To create an empty lazy store, use .create()
+
+        Parameters
+        ----------
+        root : str
+            Root of parquet store
+        fs : fsspec.AbstractFileSystem
+            fsspec filesystem object, default is local filesystem.
+        cache_size : int, default=128
+            Maximum size of LRU cache, where cache_size*record_size denotes
+            the total number of references that can be loaded in memory at once.
+        categorical_threshold : int
+            Encode urls as pandas.Categorical to reduce memory footprint if the ratio
+            of the number of unique urls to total number of refs for each variable
+            is greater than or equal to this number. (default 10)
+        engine: Literal["fastparquet","pyarrow"]
+            Engine choice for reading parquet files. (default is "fastparquet")
+        """
+
+        self.root = root
+        self.chunk_sizes = {}
+        self.cat_thresh = categorical_threshold
+        self.engine = engine
+        self.cache_size = cache_size
+        self.url = self.root + "/{field}/refs.{record}.parq"
+        # TODO: derive fs from `root`
+        self.fs = fsspec.filesystem("file") if fs is None else fs
+        self.out_root = self.fs.unstrip_protocol(out_root or self.root)
+
+        from importlib.util import find_spec
+
+        if self.engine == "pyarrow" and find_spec("pyarrow") is None:
+            raise ImportError("engine choice `pyarrow` is not installed.")
+
+        # Apply `lru_cache` decorator manually per instance.
+        # This way `self` reference is not held on class level.
+        # WARNING: However, this means that self and its members are not reflected
+        # in the cache key, so we expect they won't be mutated once a value is cached.
+        self.listdir = lru_cache()(self.listdir)
+        self._key_to_record = lru_cache(maxsize=4096)(self._key_to_record)
+
+    def __getattr__(self, item):
+        if item in ("_items", "record_size", "zmetadata"):
+            self.setup()
+            # avoid possible recursion if setup fails somehow
+            return self.__dict__[item]
+        raise AttributeError(item)
+
+    def setup(self):
+        self._items = {}
+        self._items[".zmetadata"] = self.fs.cat_file(
+            "/".join([self.root, ".zmetadata"])
+        )
+        met = json.loads(self._items[".zmetadata"])
+        self.record_size = met["record_size"]
+        self.zmetadata = met["metadata"]
+
+        # Define function to open and decompress refs
+        @lru_cache(maxsize=self.cache_size)
+        def open_refs(field, record):
+            """cached parquet file loader"""
+            path = self.url.format(field=field, record=record)
+            data = io.BytesIO(self.fs.cat_file(path))
+            try:
+                df = self.pd.read_parquet(data, engine=self.engine)
+                refs = {c: df[c].to_numpy(copy=True) for c in df.columns}
+            except OSError:
+                refs = None
+            return refs
+
+        self.open_refs = open_refs
+
+    @staticmethod
+    def create(root, storage_options=None, fs=None, record_size=10000, **kwargs):
+        """Make empty parquet reference set
+
+        First deletes the contents of the given directory, if it exists.
+
+        Parameters
+        ----------
+        root: str
+            Directory to contain the output; will be created
+        storage_options: dict | None
+            For making the filesystem to use for writing is fs is None
+        fs: FileSystem | None
+            Filesystem for writing
+        record_size: int
+            Number of references per parquet file
+        kwargs: passed to __init__
+
+        Returns
+        -------
+        LazyReferenceMapper instance
+        """
+        met = {"metadata": {}, "record_size": record_size}
+        if fs is None:
+            fs, root = fsspec.core.url_to_fs(root, **(storage_options or {}))
+        if fs.exists(root):
+            fs.rm(root, recursive=True)
+        fs.makedirs(root, exist_ok=True)
+        fs.pipe("/".join([root, ".zmetadata"]), json.dumps(met).encode())
+        return LazyReferenceMapper(root, fs, **kwargs)
+
+    def listdir(self):
+        """List top-level directories"""
+        dirs = (p.rsplit("/", 1)[0] for p in self.zmetadata if not p.startswith(".z"))
+        return set(dirs)
+
+    def ls(self, path="", detail=True):
+        """Shortcut file listings"""
+        path = path.rstrip("/")
+        pathdash = path + "/" if path else ""
+        dirnames = self.listdir()
+        dirs = [
+            d
+            for d in dirnames
+            if d.startswith(pathdash) and "/" not in d.lstrip(pathdash)
+        ]
+        if dirs:
+            others = {
+                f
+                for f in chain(
+                    [".zmetadata"],
+                    (name for name in self.zmetadata),
+                    (name for name in self._items),
+                )
+                if f.startswith(pathdash) and "/" not in f.lstrip(pathdash)
+            }
+            if detail is False:
+                others.update(dirs)
+                return sorted(others)
+            dirinfo = [{"name": name, "type": "directory", "size": 0} for name in dirs]
+            fileinfo = [
+                {
+                    "name": name,
+                    "type": "file",
+                    "size": len(
+                        json.dumps(self.zmetadata[name])
+                        if name in self.zmetadata
+                        else self._items[name]
+                    ),
+                }
+                for name in others
+            ]
+            return sorted(dirinfo + fileinfo, key=lambda s: s["name"])
+        field = path
+        others = set(
+            [name for name in self.zmetadata if name.startswith(f"{path}/")]
+            + [name for name in self._items if name.startswith(f"{path}/")]
+        )
+        fileinfo = [
+            {
+                "name": name,
+                "type": "file",
+                "size": len(
+                    json.dumps(self.zmetadata[name])
+                    if name in self.zmetadata
+                    else self._items[name]
+                ),
+            }
+            for name in others
+        ]
+        keys = self._keys_in_field(field)
+
+        if detail is False:
+            return list(others) + list(keys)
+        recs = self._generate_all_records(field)
+        recinfo = [
+            {"name": name, "type": "file", "size": rec[-1]}
+            for name, rec in zip(keys, recs)
+            if rec[0]  # filters out path==None, deleted/missing
+        ]
+        return fileinfo + recinfo
+
+    def _load_one_key(self, key):
+        """Get the reference for one key
+
+        Returns bytes, one-element list or three-element list.
+        """
+        if key in self._items:
+            return self._items[key]
+        elif key in self.zmetadata:
+            return json.dumps(self.zmetadata[key]).encode()
+        elif "/" not in key or self._is_meta(key):
+            raise KeyError(key)
+        field, _ = key.rsplit("/", 1)
+        record, ri, chunk_size = self._key_to_record(key)
+        maybe = self._items.get((field, record), {}).get(ri, False)
+        if maybe is None:
+            # explicitly deleted
+            raise KeyError
+        elif maybe:
+            return maybe
+        elif chunk_size == 0:
+            return b""
+
+        # Chunk keys can be loaded from row group and cached in LRU cache
+        try:
+            refs = self.open_refs(field, record)
+        except (ValueError, TypeError, FileNotFoundError) as exc:
+            raise KeyError(key) from exc
+        columns = ["path", "offset", "size", "raw"]
+        selection = [refs[c][ri] if c in refs else None for c in columns]
+        raw = selection[-1]
+        if raw is not None:
+            return raw
+        if selection[0] is None:
+            raise KeyError("This reference does not exist or has been deleted")
+        if selection[1:3] == [0, 0]:
+            # URL only
+            return selection[:1]
+        # URL, offset, size
+        return selection[:3]
+
+    def _key_to_record(self, key):
+        """Details needed to construct a reference for one key"""
+        field, chunk = key.rsplit("/", 1)
+        chunk_sizes = self._get_chunk_sizes(field)
+        if len(chunk_sizes) == 0:
+            return 0, 0, 0
+        chunk_idx = [int(c) for c in chunk.split(".")]
+        chunk_number = ravel_multi_index(chunk_idx, chunk_sizes)
+        record = chunk_number // self.record_size
+        ri = chunk_number % self.record_size
+        return record, ri, len(chunk_sizes)
+
+    def _get_chunk_sizes(self, field):
+        """The number of chunks along each axis for a given field"""
+        if field not in self.chunk_sizes:
+            zarray = self.zmetadata[f"{field}/.zarray"]
+            size_ratio = [
+                math.ceil(s / c) for s, c in zip(zarray["shape"], zarray["chunks"])
+            ]
+            self.chunk_sizes[field] = size_ratio or [1]
+        return self.chunk_sizes[field]
+
+    def _generate_record(self, field, record):
+        """The references for a given parquet file of a given field"""
+        refs = self.open_refs(field, record)
+        it = iter(zip(*refs.values()))
+        if len(refs) == 3:
+            # All urls
+            return (list(t) for t in it)
+        elif len(refs) == 1:
+            # All raws
+            return refs["raw"]
+        else:
+            # Mix of urls and raws
+            return (list(t[:3]) if not t[3] else t[3] for t in it)
+
+    def _generate_all_records(self, field):
+        """Load all the references within a field by iterating over the parquet files"""
+        nrec = 1
+        for ch in self._get_chunk_sizes(field):
+            nrec *= ch
+        nrec = math.ceil(nrec / self.record_size)
+        for record in range(nrec):
+            yield from self._generate_record(field, record)
+
+    def values(self):
+        return RefsValuesView(self)
+
+    def items(self):
+        return RefsItemsView(self)
+
+    def __hash__(self):
+        return id(self)
+
+    def __getitem__(self, key):
+        return self._load_one_key(key)
+
+    def __setitem__(self, key, value):
+        if "/" in key and not self._is_meta(key):
+            field, chunk = key.rsplit("/", 1)
+            record, i, _ = self._key_to_record(key)
+            subdict = self._items.setdefault((field, record), {})
+            subdict[i] = value
+            if len(subdict) == self.record_size:
+                self.write(field, record)
+        else:
+            # metadata or top-level
+            if hasattr(value, "to_bytes"):
+                val = value.to_bytes().decode()
+            elif isinstance(value, bytes):
+                val = value.decode()
+            else:
+                val = value
+            self._items[key] = val
+            new_value = json.loads(val)
+            self.zmetadata[key] = {**self.zmetadata.get(key, {}), **new_value}
+
+    @staticmethod
+    def _is_meta(key):
+        return key.startswith(".z") or "/.z" in key
+
+    def __delitem__(self, key):
+        if key in self._items:
+            del self._items[key]
+        elif key in self.zmetadata:
+            del self.zmetadata[key]
+        else:
+            if "/" in key and not self._is_meta(key):
+                field, _ = key.rsplit("/", 1)
+                record, i, _ = self._key_to_record(key)
+                subdict = self._items.setdefault((field, record), {})
+                subdict[i] = None
+                if len(subdict) == self.record_size:
+                    self.write(field, record)
+            else:
+                # metadata or top-level
+                self._items[key] = None
+
+    def write(self, field, record, base_url=None, storage_options=None):
+        # extra requirements if writing
+        import kerchunk.df
+        import numpy as np
+        import pandas as pd
+
+        partition = self._items[(field, record)]
+        original = False
+        if len(partition) < self.record_size:
+            try:
+                original = self.open_refs(field, record)
+            except OSError:
+                pass
+
+        if original:
+            paths = original["path"]
+            offsets = original["offset"]
+            sizes = original["size"]
+            raws = original["raw"]
+        else:
+            paths = np.full(self.record_size, np.nan, dtype="O")
+            offsets = np.zeros(self.record_size, dtype="int64")
+            sizes = np.zeros(self.record_size, dtype="int64")
+            raws = np.full(self.record_size, np.nan, dtype="O")
+        for j, data in partition.items():
+            if isinstance(data, list):
+                if (
+                    str(paths.dtype) == "category"
+                    and data[0] not in paths.dtype.categories
+                ):
+                    paths = paths.add_categories(data[0])
+                paths[j] = data[0]
+                if len(data) > 1:
+                    offsets[j] = data[1]
+                    sizes[j] = data[2]
+            elif data is None:
+                # delete
+                paths[j] = None
+                offsets[j] = 0
+                sizes[j] = 0
+                raws[j] = None
+            else:
+                # this is the only call into kerchunk, could remove
+                raws[j] = kerchunk.df._proc_raw(data)
+        # TODO: only save needed columns
+        df = pd.DataFrame(
+            {
+                "path": paths,
+                "offset": offsets,
+                "size": sizes,
+                "raw": raws,
+            },
+            copy=False,
+        )
+        if df.path.count() / (df.path.nunique() or 1) > self.cat_thresh:
+            df["path"] = df["path"].astype("category")
+        object_encoding = {"raw": "bytes", "path": "utf8"}
+        has_nulls = ["path", "raw"]
+
+        fn = f"{base_url or self.out_root}/{field}/refs.{record}.parq"
+        self.fs.mkdirs(f"{base_url or self.out_root}/{field}", exist_ok=True)
+
+        if self.engine == "pyarrow":
+            df_backend_kwargs = {"write_statistics": False}
+        elif self.engine == "fastparquet":
+            df_backend_kwargs = {
+                "stats": False,
+                "object_encoding": object_encoding,
+                "has_nulls": has_nulls,
+            }
+        else:
+            raise NotImplementedError(f"{self.engine} not supported")
+        df.to_parquet(
+            fn,
+            engine=self.engine,
+            storage_options=storage_options
+            or getattr(self.fs, "storage_options", None),
+            compression="zstd",
+            index=False,
+            **df_backend_kwargs,
+        )
+
+        partition.clear()
+        self._items.pop((field, record))
+
+    def flush(self, base_url=None, storage_options=None):
+        """Output any modified or deleted keys
+
+        Parameters
+        ----------
+        base_url: str
+            Location of the output
+        """
+
+        # write what we have so far and clear sub chunks
+        for thing in list(self._items):
+            if isinstance(thing, tuple):
+                field, record = thing
+                self.write(
+                    field,
+                    record,
+                    base_url=base_url,
+                    storage_options=storage_options,
+                )
+
+        # gather .zmetadata from self._items and write that too
+        for k in list(self._items):
+            if k != ".zmetadata" and ".z" in k:
+                self.zmetadata[k] = json.loads(self._items.pop(k))
+        met = {"metadata": self.zmetadata, "record_size": self.record_size}
+        self._items.clear()
+        self._items[".zmetadata"] = json.dumps(met).encode()
+        self.fs.pipe(
+            "/".join([base_url or self.out_root, ".zmetadata"]),
+            self._items[".zmetadata"],
+        )
+
+        # TODO: only clear those that we wrote to?
+        self.open_refs.cache_clear()
+
+    def __len__(self):
+        # Caveat: This counts expected references, not actual - but is fast
+        count = 0
+        for field in self.listdir():
+            if field.startswith("."):
+                count += 1
+            else:
+                count += math.prod(self._get_chunk_sizes(field))
+        count += len(self.zmetadata)  # all metadata keys
+        # any other files not in reference partitions
+        count += sum(1 for _ in self._items if not isinstance(_, tuple))
+        return count
+
+    def __iter__(self):
+        # Caveat: returns only existing keys, so the number of these does not
+        #  match len(self)
+        metas = set(self.zmetadata)
+        metas.update(self._items)
+        for bit in metas:
+            if isinstance(bit, str):
+                yield bit
+        for field in self.listdir():
+            for k in self._keys_in_field(field):
+                if k in self:
+                    yield k
+
+    def __contains__(self, item):
+        try:
+            self._load_one_key(item)
+            return True
+        except KeyError:
+            return False
+
+    def _keys_in_field(self, field):
+        """List key names in given field
+
+        Produces strings like "field/x.y" appropriate from the chunking of the array
+        """
+        chunk_sizes = self._get_chunk_sizes(field)
+        if len(chunk_sizes) == 0:
+            yield field + "/0"
+            return
+        inds = itertools.product(*(range(i) for i in chunk_sizes))
+        for ind in inds:
+            yield field + "/" + ".".join([str(c) for c in ind])
+
+
+class ReferenceFileSystem(AsyncFileSystem):
+    """View byte ranges of some other file as a file system
+    Initial version: single file system target, which must support
+    async, and must allow start and end args in _cat_file. Later versions
+    may allow multiple arbitrary URLs for the targets.
+    This FileSystem is read-only. It is designed to be used with async
+    targets (for now). We do not get original file details from the target FS.
+    Configuration is by passing a dict of references at init, or a URL to
+    a JSON file containing the same; this dict
+    can also contain concrete data for some set of paths.
+    Reference dict format:
+    {path0: bytes_data, path1: (target_url, offset, size)}
+    https://github.com/fsspec/kerchunk/blob/main/README.md
+
+    simple_references: if True (default), no jinja interpreting is done,
+        which is the safe option.
+    """
+
+    protocol = "reference"
+    cachable = False
+
+    def __init__(
+        self,
+        fo,
+        target=None,
+        ref_storage_args=None,
+        target_protocol=None,
+        target_options=None,
+        remote_protocol=None,
+        remote_options=None,
+        fs=None,
+        template_overrides=None,
+        simple_templates=True,
+        max_gap=64_000,
+        max_block=256_000_000,
+        cache_size=128,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo : dict or str
+            The set of references to use for this instance, with a structure as above.
+            If str referencing a JSON file, will use fsspec.open, in conjunction
+            with target_options and target_protocol to open and parse JSON at this
+            location. If a directory, then assume references are a set of parquet
+            files to be loaded lazily.
+        target : str
+            For any references having target_url as None, this is the default file
+            target to use
+        ref_storage_args : dict
+            If references is a str, use these kwargs for loading the JSON file.
+            Deprecated: use target_options instead.
+        target_protocol : str
+            Used for loading the reference file, if it is a path. If None, protocol
+            will be derived from the given path
+        target_options : dict
+            Extra FS options for loading the reference file ``fo``, if given as a path
+        remote_protocol : str
+            The protocol of the filesystem on which the references will be evaluated
+            (unless fs is provided). If not given, will be derived from the first
+            URL that has a protocol in the templates or in the references, in that
+            order.
+        remote_options : dict
+            kwargs to go with remote_protocol
+        fs : AbstractFileSystem | dict(str, (AbstractFileSystem | dict))
+            Directly provide a file system(s):
+                - a single filesystem instance
+                - a dict of protocol:filesystem, where each value is either a filesystem
+                  instance, or a dict of kwargs that can be used to create in
+                  instance for the given protocol
+
+            If this is given, remote_options and remote_protocol are ignored.
+        template_overrides : dict
+            Swap out any templates in the references file with these - useful for
+            testing.
+        simple_templates: bool
+            Whether templates can be processed with simple replace (True) or if
+            jinja  is needed (False, much slower). All reference sets produced by
+            ``kerchunk`` are simple in this sense, but the spec allows for complex.
+        max_gap, max_block: int
+            For merging multiple concurrent requests to the same remote file.
+            Neighboring byte ranges will only be merged when their
+            inter-range gap is <= ``max_gap``. Default is 64KB. Set to 0
+            to only merge when it requires no extra bytes. Pass a negative
+            number to disable merging, appropriate for local target files.
+            Neighboring byte ranges will only be merged when the size of
+            the aggregated range is <= ``max_block``. Default is 256MB.
+        cache_size : int
+            Maximum size of LRU cache, where cache_size*record_size denotes
+            the total number of references that can be loaded in memory at once.
+            Only used for lazily loaded references.
+        kwargs : passed to parent class
+        """
+        super().__init__(**kwargs)
+        self.target = target
+        self.template_overrides = template_overrides
+        self.simple_templates = simple_templates
+        self.templates = {}
+        self.fss = {}
+        self._dircache = {}
+        self.max_gap = max_gap
+        self.max_block = max_block
+        if isinstance(fo, str):
+            dic = dict(
+                **(ref_storage_args or target_options or {}), protocol=target_protocol
+            )
+            ref_fs, fo2 = fsspec.core.url_to_fs(fo, **dic)
+            if ".json" not in fo2 and (
+                fo.endswith(("parq", "parquet", "/")) or ref_fs.isdir(fo2)
+            ):
+                # Lazy parquet refs
+                logger.info("Open lazy reference dict from URL %s", fo)
+                self.references = LazyReferenceMapper(
+                    fo2,
+                    fs=ref_fs,
+                    cache_size=cache_size,
+                )
+            else:
+                # text JSON
+                with fsspec.open(fo, "rb", **dic) as f:
+                    logger.info("Read reference from URL %s", fo)
+                    text = json.load(f)
+                self._process_references(text, template_overrides)
+        else:
+            # dictionaries
+            self._process_references(fo, template_overrides)
+        if isinstance(fs, dict):
+            self.fss = {
+                k: (
+                    fsspec.filesystem(k.split(":", 1)[0], **opts)
+                    if isinstance(opts, dict)
+                    else opts
+                )
+                for k, opts in fs.items()
+            }
+            if None not in self.fss:
+                self.fss[None] = filesystem("file")
+            return
+        if fs is not None:
+            # single remote FS
+            remote_protocol = (
+                fs.protocol[0] if isinstance(fs.protocol, tuple) else fs.protocol
+            )
+            self.fss[remote_protocol] = fs
+
+        if remote_protocol is None:
+            # get single protocol from any templates
+            for ref in self.templates.values():
+                if callable(ref):
+                    ref = ref()
+                protocol, _ = fsspec.core.split_protocol(ref)
+                if protocol and protocol not in self.fss:
+                    fs = filesystem(protocol, **(remote_options or {}))
+                    self.fss[protocol] = fs
+        if remote_protocol is None:
+            # get single protocol from references
+            # TODO: warning here, since this can be very expensive?
+            for ref in self.references.values():
+                if callable(ref):
+                    ref = ref()
+                if isinstance(ref, list) and ref[0]:
+                    protocol, _ = fsspec.core.split_protocol(ref[0])
+                    if protocol not in self.fss:
+                        fs = filesystem(protocol, **(remote_options or {}))
+                        self.fss[protocol] = fs
+                        # only use first remote URL
+                        break
+
+        if remote_protocol and remote_protocol not in self.fss:
+            fs = filesystem(remote_protocol, **(remote_options or {}))
+            self.fss[remote_protocol] = fs
+
+        self.fss[None] = fs or filesystem("file")  # default one
+        # Wrap any non-async filesystems to ensure async methods are available below
+        for k, f in self.fss.items():
+            if not f.async_impl:
+                self.fss[k] = AsyncFileSystemWrapper(f, asynchronous=self.asynchronous)
+            elif self.asynchronous ^ f.asynchronous:
+                raise ValueError(
+                    "Reference-FS's target filesystem must have same value "
+                    "of asynchronous"
+                )
+
+    def _cat_common(self, path, start=None, end=None):
+        path = self._strip_protocol(path)
+        logger.debug(f"cat: {path}")
+        try:
+            part = self.references[path]
+        except KeyError as exc:
+            raise FileNotFoundError(path) from exc
+        if isinstance(part, str):
+            part = part.encode()
+        if hasattr(part, "to_bytes"):
+            part = part.to_bytes()
+        if isinstance(part, bytes):
+            logger.debug(f"Reference: {path}, type bytes")
+            if part.startswith(b"base64:"):
+                part = base64.b64decode(part[7:])
+            return part, None, None
+
+        if len(part) == 1:
+            logger.debug(f"Reference: {path}, whole file => {part}")
+            url = part[0]
+            start1, end1 = start, end
+        else:
+            url, start0, size = part
+            logger.debug(f"Reference: {path} => {url}, offset {start0}, size {size}")
+            end0 = start0 + size
+
+            # Resolve offsets like slicing the part, so they never reach target
+            # bytes outside the referenced range.
+            if start is not None:
+                if start >= 0:
+                    start1 = min(start0 + start, end0)
+                else:
+                    start1 = max(end0 + start, start0)
+            else:
+                start1 = start0
+            if end is not None:
+                if end >= 0:
+                    end1 = min(start0 + end, end0)
+                else:
+                    end1 = max(end0 + end, start0)
+            else:
+                end1 = end0
+        if url is None:
+            url = self.target
+        return url, start1, end1
+
+    async def _cat_file(self, path, start=None, end=None, **kwargs):
+        part_or_url, start0, end0 = self._cat_common(path, start=start, end=end)
+        if isinstance(part_or_url, bytes):
+            return part_or_url[start:end]
+        protocol, _ = split_protocol(part_or_url)
+        try:
+            return await self.fss[protocol]._cat_file(
+                part_or_url, start=start0, end=end0
+            )
+        except Exception as e:
+            raise ReferenceNotReachable(path, part_or_url) from e
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        part_or_url, start0, end0 = self._cat_common(path, start=start, end=end)
+        if isinstance(part_or_url, bytes):
+            return part_or_url[start:end]
+        protocol, _ = split_protocol(part_or_url)
+        try:
+            return self.fss[protocol].cat_file(part_or_url, start=start0, end=end0)
+        except Exception as e:
+            raise ReferenceNotReachable(path, part_or_url) from e
+
+    def pipe_file(self, path, value, **_):
+        """Temporarily add binary data or reference as a file"""
+        self.references[path] = value
+
+    async def _get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            return os.makedirs(lpath, exist_ok=True)
+        data = await self._cat_file(rpath)
+        with open(lpath, "wb") as f:
+            f.write(data)
+
+    def get_file(self, rpath, lpath, callback=DEFAULT_CALLBACK, **kwargs):
+        if self.isdir(rpath):
+            return os.makedirs(lpath, exist_ok=True)
+        data = self.cat_file(rpath, **kwargs)
+        callback.set_size(len(data))
+        if isfilelike(lpath):
+            lpath.write(data)
+        else:
+            with open(lpath, "wb") as f:
+                f.write(data)
+        callback.absolute_update(len(data))
+
+    def get(self, rpath, lpath, recursive=False, **kwargs):
+        if recursive:
+            # trigger directory build
+            self.ls("")
+        rpath = self.expand_path(rpath, recursive=recursive)
+        fs = fsspec.filesystem("file", auto_mkdir=True)
+        targets = other_paths(rpath, lpath)
+        if isinstance(lpath, str):
+            # The names came from the source listing; ".." in one of them
+            # would otherwise place the copy above the destination. When
+            # lpath is a list the caller named every destination itself.
+            check_contained(lpath, targets)
+        if recursive:
+            data = self.cat([r for r in rpath if not self.isdir(r)])
+        else:
+            data = self.cat(rpath)
+        for remote, local in zip(rpath, targets):
+            if remote in data:
+                fs.pipe_file(local, data[remote])
+
+    def cat(self, path, recursive=False, on_error="raise", **kwargs):
+        if isinstance(path, str) and recursive:
+            raise NotImplementedError
+        if isinstance(path, list) and (recursive or any("*" in p for p in path)):
+            raise NotImplementedError
+        # TODO: if references is lazy, pre-fetch all paths in batch before access
+        proto_dict = _protocol_groups(path, self.references)
+        out = {}
+        for proto, paths in proto_dict.items():
+            fs = self.fss[proto]
+            urls, starts, ends, valid_paths = [], [], [], []
+            for p in paths:
+                # find references or label not-found. Early exit if any not
+                # found and on_error is "raise"
+                try:
+                    u, s, e = self._cat_common(p)
+                    if not isinstance(u, (bytes, str)):
+                        # nan/None from parquet
+                        continue
+                except FileNotFoundError as err:
+                    if on_error == "raise":
+                        raise
+                    if on_error != "omit":
+                        out[p] = err
+                else:
+                    urls.append(u)
+                    starts.append(s)
+                    ends.append(e)
+                    valid_paths.append(p)
+
+            # process references into form for merging
+            urls2 = []
+            starts2 = []
+            ends2 = []
+            paths2 = []
+            whole_files = set()
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                if isinstance(u, bytes):
+                    # data
+                    out[p] = u
+                elif s is None:
+                    # whole file - limits are None, None, but no further
+                    # entries take for this file
+                    whole_files.add(u)
+                    urls2.append(u)
+                    starts2.append(s)
+                    ends2.append(e)
+                    paths2.append(p)
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                # second run to account for files that are to be loaded whole
+                if s is not None and u not in whole_files:
+                    urls2.append(u)
+                    starts2.append(s)
+                    ends2.append(e)
+                    paths2.append(p)
+
+            # merge and fetch consolidated ranges
+            new_paths, new_starts, new_ends = merge_offset_ranges(
+                list(urls2),
+                list(starts2),
+                list(ends2),
+                sort=True,
+                max_gap=self.max_gap,
+                max_block=self.max_block,
+            )
+            bytes_out = fs.cat_ranges(new_paths, new_starts, new_ends)
+
+            # unbundle from merged bytes - simple approach
+            for u, s, e, p in zip(urls, starts, ends, valid_paths):
+                if p in out:
+                    continue  # was bytes, already handled
+                for np, ns, ne, b in zip(new_paths, new_starts, new_ends, bytes_out):
+                    if np == u and (ns is None or ne is None):
+                        if isinstance(b, Exception):
+                            out[p] = b
+                        else:
+                            out[p] = b[s:e]
+                    elif np == u and s >= ns and e <= ne:
+                        if isinstance(b, Exception):
+                            out[p] = b
+                        else:
+                            out[p] = b[s - ns : (e - ne) or None]
+
+        for k, v in out.copy().items():
+            # these were valid references, but fetch failed, so transform exc
+            if isinstance(v, Exception) and k in self.references:
+                ex = out[k]
+                new_ex = ReferenceNotReachable(k, self.references[k])
+                new_ex.__cause__ = ex
+                if on_error == "raise":
+                    raise new_ex
+                elif on_error != "omit":
+                    out[k] = new_ex
+
+        if len(out) == 1 and isinstance(path, str) and "*" not in path:
+            return _first(out)
+        return out
+
+    def _process_references(self, references, template_overrides=None):
+        vers = references.get("version", None)
+        if vers is None:
+            self._process_references0(references)
+        elif vers == 1:
+            self._process_references1(references, template_overrides=template_overrides)
+        else:
+            raise ValueError(f"Unknown reference spec version: {vers}")
+        # TODO: we make dircache by iterating over all entries, but for Spec >= 1,
+        #  can replace with programmatic. Is it even needed for mapper interface?
+
+    def _process_references0(self, references):
+        """Make reference dict for Spec Version 0"""
+        if isinstance(references, dict):
+            # do not do this for lazy/parquet backend, which will not make dicts,
+            # but must remain writable in the original object
+            references = {
+                key: json.dumps(val) if isinstance(val, dict) else val
+                for key, val in references.items()
+            }
+        self.references = references
+
+    def _process_references1(self, references, template_overrides=None):
+        if not self.simple_templates or self.templates:
+            import jinja2.sandbox
+        self.references = {}
+        self._process_templates(references.get("templates", {}))
+
+        @lru_cache(1000)
+        def _render_jinja(u):
+            return (
+                jinja2.sandbox.SandboxedEnvironment()
+                .from_string(u)
+                .render(**self.templates)
+            )
+
+        for k, v in references.get("refs", {}).items():
+            if isinstance(v, str):
+                if v.startswith("base64:"):
+                    self.references[k] = base64.b64decode(v[7:])
+                self.references[k] = v
+            elif isinstance(v, dict):
+                self.references[k] = json.dumps(v)
+            elif self.templates:
+                u = v[0]
+                if "{{" in u:
+                    if self.simple_templates:
+                        u = (
+                            u.replace("{{", "{")
+                            .replace("}}", "}")
+                            .format(**self.templates)
+                        )
+                    else:
+                        u = _render_jinja(u)
+                self.references[k] = [u] if len(v) == 1 else [u, v[1], v[2]]
+            else:
+                self.references[k] = v
+        self.references.update(self._process_gen(references.get("gen", [])))
+
+    def _process_templates(self, tmp):
+        self.templates = {}
+        if self.template_overrides is not None:
+            tmp.update(self.template_overrides)
+        for k, v in tmp.items():
+            if "{{" in v:
+                import jinja2.sandbox
+
+                self.templates[k] = (
+                    lambda temp=v, **kwargs: jinja2.sandbox.SandboxedEnvironment()
+                    .from_string(temp)
+                    .render(**kwargs)
+                )
+            else:
+                self.templates[k] = v
+
+    def _process_gen(self, gens):
+        out = {}
+        if self.simple_templates:
+            return out
+        for gen in gens:
+            dimension = {
+                k: (
+                    v
+                    if isinstance(v, list)
+                    else range(v.get("start", 0), v["stop"], v.get("step", 1))
+                )
+                for k, v in gen["dimensions"].items()
+            }
+            products = (
+                dict(zip(dimension.keys(), values))
+                for values in itertools.product(*dimension.values())
+            )
+            for pr in products:
+                import jinja2.sandbox
+
+                key = (
+                    jinja2.sandbox.SandboxedEnvironment()
+                    .from_string(gen["key"])
+                    .render(**pr, **self.templates)
+                )
+                url = (
+                    jinja2.sandbox.SandboxedEnvironment()
+                    .from_string(gen["url"])
+                    .render(**pr, **self.templates)
+                )
+                if ("offset" in gen) and ("length" in gen):
+                    offset = int(
+                        jinja2.sandbox.SandboxedEnvironment()
+                        .from_string(gen["offset"])
+                        .render(**pr, **self.templates)
+                    )
+                    length = int(
+                        jinja2.sandbox.SandboxedEnvironment()
+                        .from_string(gen["length"])
+                        .render(**pr, **self.templates)
+                    )
+                    out[key] = [url, offset, length]
+                elif ("offset" in gen) ^ ("length" in gen):
+                    raise ValueError(
+                        "Both 'offset' and 'length' are required for a "
+                        "reference generator entry if either is provided."
+                    )
+                else:
+                    out[key] = [url]
+        return out
+
+    def _dircache_from_items(self):
+        self.dircache = {"": []}
+        it = self.references.items()
+        for path, part in it:
+            if isinstance(part, (bytes, str)) or hasattr(part, "to_bytes"):
+                size = len(part)
+            elif len(part) == 1:
+                size = None
+            else:
+                _, _, size = part
+            par = path.rsplit("/", 1)[0] if "/" in path else ""
+            par0 = par
+            subdirs = [par0]
+            while par0 and par0 not in self.dircache:
+                # collect parent directories
+                par0 = self._parent(par0)
+                subdirs.append(par0)
+
+            subdirs.reverse()
+            for parent, child in zip(subdirs, subdirs[1:]):
+                # register newly discovered directories
+                assert child not in self.dircache
+                assert parent in self.dircache
+                self.dircache[parent].append(
+                    {"name": child, "type": "directory", "size": 0}
+                )
+                self.dircache[child] = []
+
+            self.dircache[par].append({"name": path, "type": "file", "size": size})
+
+    def _open(self, path, mode="rb", block_size=None, cache_options=None, **kwargs):
+        part_or_url, start0, end0 = self._cat_common(path)
+        # This logic is kept outside `ReferenceFile` to avoid unnecessary redirection.
+        # That does mean `_cat_common` gets called twice if it eventually reaches `ReferenceFile`.
+        if isinstance(part_or_url, bytes):
+            return io.BytesIO(part_or_url[start0:end0])
+
+        protocol, _ = split_protocol(part_or_url)
+        if start0 is None and end0 is None:
+            return self.fss[protocol]._open(
+                part_or_url,
+                mode,
+                block_size=block_size,
+                cache_options=cache_options,
+                **kwargs,
+            )
+
+        return ReferenceFile(
+            self,
+            path,
+            mode,
+            block_size=block_size,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def ls(self, path, detail=True, **kwargs):
+        logger.debug("list %s", path)
+        path = self._strip_protocol(path)
+        if isinstance(self.references, LazyReferenceMapper):
+            try:
+                return self.references.ls(path, detail)
+            except KeyError:
+                pass
+            raise FileNotFoundError(f"'{path}' is not a known key")
+        if not self.dircache:
+            self._dircache_from_items()
+        out = self._ls_from_cache(path)
+        if out is None:
+            raise FileNotFoundError(path)
+        if detail:
+            return out
+        return [o["name"] for o in out]
+
+    def exists(self, path, **kwargs):  # overwrite auto-sync version
+        return self.isdir(path) or self.isfile(path)
+
+    def isdir(self, path):  # overwrite auto-sync version
+        if self.dircache:
+            return path in self.dircache
+        elif isinstance(self.references, LazyReferenceMapper):
+            return path in self.references.listdir()
+        else:
+            # this may be faster than building dircache for single calls, but
+            # by looping will be slow for many calls; could cache it?
+            return any(_.startswith(f"{path}/") for _ in self.references)
+
+    def isfile(self, path):  # overwrite auto-sync version
+        return path in self.references
+
+    async def _ls(self, path, detail=True, **kwargs):  # calls fast sync code
+        return self.ls(path, detail, **kwargs)
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        if withdirs:
+            return super().find(
+                path, maxdepth=maxdepth, withdirs=withdirs, detail=detail, **kwargs
+            )
+        if path:
+            path = self._strip_protocol(path)
+            r = sorted(k for k in self.references if k.startswith(path))
+        else:
+            r = sorted(self.references)
+        if detail:
+            if not self.dircache:
+                self._dircache_from_items()
+            return {k: self._ls_from_cache(k)[0] for k in r}
+        else:
+            return r
+
+    def info(self, path, **kwargs):
+        out = self.references.get(path)
+        if out is not None:
+            if isinstance(out, (str, bytes)):
+                # decode base64 here
+                return {"name": path, "type": "file", "size": len(out)}
+            elif len(out) > 1:
+                return {"name": path, "type": "file", "size": out[2]}
+            else:
+                out0 = [{"name": path, "type": "file", "size": None}]
+        else:
+            out = self.ls(path, True)
+            out0 = [o for o in out if o["name"] == path]
+            if not out0:
+                return {"name": path, "type": "directory", "size": 0}
+        if out0[0]["size"] is None:
+            # if this is a whole remote file, update size using remote FS
+            prot, _ = split_protocol(self.references[path][0])
+            out0[0]["size"] = self.fss[prot].size(self.references[path][0])
+        return out0[0]
+
+    async def _info(self, path, **kwargs):
+        out = self.references.get(path)
+        if isinstance(out, (list, tuple)) and len(out) == 1:
+            # whole remote file: the size must come from the remote FS, which
+            # cannot be called synchronously from inside the event loop
+            prot, _ = split_protocol(out[0])
+            fs = self.fss[prot]
+            if fs.async_impl:
+                size = await fs._size(out[0])
+            else:
+                size = fs.size(out[0])
+            return {"name": path, "type": "file", "size": size}
+        return self.info(path)  # calls fast sync code
+
+    async def _rm_file(self, path, **kwargs):
+        self.references.pop(
+            path, None
+        )  # ignores FileNotFound, just as well for directories
+        self.dircache.clear()  # this is a bit heavy handed
+
+    async def _pipe_file(self, path, data, mode="overwrite", **kwargs):
+        if mode == "create" and self.exists(path):
+            raise FileExistsError
+        # can be str or bytes
+        self.references[path] = data
+        self.dircache.clear()  # this is a bit heavy handed
+
+    async def _put_file(self, lpath, rpath, mode="overwrite", **kwargs):
+        # puts binary
+        if mode == "create" and self.exists(rpath):
+            raise FileExistsError
+        with open(lpath, "rb") as f:
+            self.references[rpath] = f.read()
+        self.dircache.clear()  # this is a bit heavy handed
+
+    def save_json(self, url, **storage_options):
+        """Write modified references into new location"""
+        out = {}
+        for k, v in self.references.items():
+            if isinstance(v, bytes):
+                try:
+                    out[k] = v.decode("ascii")
+                except UnicodeDecodeError:
+                    out[k] = (b"base64:" + base64.b64encode(v)).decode()
+            else:
+                out[k] = v
+        with fsspec.open(url, "wb", **storage_options) as f:
+            f.write(json.dumps({"version": 1, "refs": out}).encode())
+
+
+class ReferenceFile(AbstractBufferedFile):
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        super().__init__(
+            fs,
+            path,
+            mode=mode,
+            block_size=block_size,
+            autocommit=autocommit,
+            size=size,
+            cache_type=cache_type,
+            cache_options=cache_options,
+            **kwargs,
+        )
+        part_or_url, self.start, self.end = self.fs._cat_common(self.path)
+        protocol, _ = split_protocol(part_or_url)
+        self.src_fs = self.fs.fss[protocol]
+        self.src_path = part_or_url
+        self._f = None
+
+    @property
+    def f(self):
+        if self._f is None or self._f.closed:
+            self._f = self.src_fs._open(
+                self.src_path,
+                mode=self.mode,
+                block_size=self.blocksize,
+                autocommit=self.autocommit,
+                cache_type="none",
+                **self.kwargs,
+            )
+        return self._f
+
+    def close(self):
+        if self._f is not None:
+            self._f.close()
+        return super().close()
+
+    def _fetch_range(self, start, end):
+        start = start + self.start
+        end = min(end + self.start, self.end)
+        self.f.seek(start)
+        return self.f.read(end - start)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/sftp.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/sftp.py
new file mode 100644
index 0000000000000000000000000000000000000000..0386baef34ea0840e2d6db9d86db2f2aeca75d24
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/sftp.py
@@ -0,0 +1,252 @@
+import datetime
+import logging
+import os
+import types
+import uuid
+from stat import S_ISDIR, S_ISLNK
+
+import paramiko
+
+from .. import AbstractFileSystem
+from ..utils import infer_storage_options
+
+logger = logging.getLogger("fsspec.sftp")
+
+#: Short names for the missing host key policies built into paramiko, accepted
+#: as the ``host_key_policy`` argument of ``SFTPFileSystem``.
+HOST_KEY_POLICIES = {
+    "auto_add": paramiko.AutoAddPolicy,
+    "reject": paramiko.RejectPolicy,
+    "warning": paramiko.WarningPolicy,
+}
+
+
+def _resolve_host_key_policy(policy):
+    """Turn a ``host_key_policy`` argument into a paramiko policy instance."""
+    if policy is None:
+        return paramiko.AutoAddPolicy()
+    if isinstance(policy, str):
+        try:
+            return HOST_KEY_POLICIES[policy]()
+        except KeyError:
+            raise ValueError(
+                f"Unknown host_key_policy {policy!r}; expected one of "
+                f"{sorted(HOST_KEY_POLICIES)} or a paramiko.MissingHostKeyPolicy"
+            ) from None
+    if isinstance(policy, type) and issubclass(policy, paramiko.MissingHostKeyPolicy):
+        return policy()
+    if isinstance(policy, paramiko.MissingHostKeyPolicy):
+        return policy
+    raise TypeError(
+        "host_key_policy must be one of "
+        f"{sorted(HOST_KEY_POLICIES)}, a paramiko.MissingHostKeyPolicy subclass "
+        f"or instance, not {type(policy).__name__}"
+    )
+
+
+class SFTPFileSystem(AbstractFileSystem):
+    """Files over SFTP/SSH
+
+    Peer-to-peer filesystem over SSH using paramiko.
+
+    Note: if using this with the ``open`` or ``open_files``, with full URLs,
+    there is no way to tell if a path is relative, so all paths are assumed
+    to be absolute.
+    """
+
+    protocol = "sftp", "ssh"
+
+    def __init__(self, host, **ssh_kwargs):
+        """
+
+        Parameters
+        ----------
+        host: str
+            Hostname or IP as a string
+        temppath: str
+            Location on the server to put files, when within a transaction
+        host_key_policy: str or paramiko.MissingHostKeyPolicy, optional
+            Policy applied when the server presents a host key that is not
+            known yet, passed to
+            ``paramiko.SSHClient.set_missing_host_key_policy``. Either one of
+            the strings ``"auto_add"`` (default, ``paramiko.AutoAddPolicy``:
+            accept and remember any unknown key), ``"warning"``
+            (``paramiko.WarningPolicy``: log a warning and accept) or
+            ``"reject"`` (``paramiko.RejectPolicy``: refuse to connect), or a
+            ``paramiko.MissingHostKeyPolicy`` subclass or instance.
+
+            The default, ``"auto_add"``, trusts any host key presented on the
+            first connection to a host, so a man-in-the-middle attacker can
+            impersonate the server. Pass ``"reject"`` to only connect to hosts
+            whose keys are already in the known hosts of the process.
+        ssh_kwargs: dict
+            Parameters passed on to connection. See details in
+            https://docs.paramiko.org/en/3.3/api/client.html#paramiko.client.SSHClient.connect
+            May include port, username, password...
+        """
+        if self._cached:
+            return
+        super().__init__(**ssh_kwargs)
+        self.temppath = ssh_kwargs.pop("temppath", "/tmp")  # remote temp directory
+        self.host_key_policy = _resolve_host_key_policy(
+            ssh_kwargs.pop("host_key_policy", None)
+        )
+        self.host = host
+        self.ssh_kwargs = ssh_kwargs
+        self._connect()
+
+    def _connect(self):
+        logger.debug("Connecting to SFTP server %s", self.host)
+        self.client = paramiko.SSHClient()
+        self.client.set_missing_host_key_policy(self.host_key_policy)
+        self.client.connect(self.host, **self.ssh_kwargs)
+        self.ftp = self.client.open_sftp()
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def mkdir(self, path, create_parents=True, mode=511):
+        path = self._strip_protocol(path)
+        logger.debug("Creating folder %s", path)
+        if self.exists(path):
+            raise FileExistsError(f"File exists: {path}")
+
+        if create_parents:
+            self.makedirs(path)
+        else:
+            self.ftp.mkdir(path, mode)
+
+    def makedirs(self, path, exist_ok=False, mode=511):
+        if self.exists(path) and not exist_ok:
+            raise FileExistsError(f"File exists: {path}")
+
+        parts = path.split("/")
+        new_path = "/" if path[:1] == "/" else ""
+
+        for part in parts:
+            if part:
+                new_path = f"{new_path}/{part}" if new_path else part
+                if not self.exists(new_path):
+                    self.ftp.mkdir(new_path, mode)
+
+    def rmdir(self, path):
+        path = self._strip_protocol(path)
+        logger.debug("Removing folder %s", path)
+        self.ftp.rmdir(path)
+
+    def info(self, path):
+        path = self._strip_protocol(path)
+        stat = self._decode_stat(self.ftp.stat(path))
+        stat["name"] = path
+        return stat
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        # The API does not provide creation time, so we use modification time
+        info = self.info(path)
+        mtime = info.get("mtime", None)
+        if mtime is not None:
+            return mtime
+        raise RuntimeError("Could not retrieve creation time (modification time).")
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        info = self.info(path)
+        mtime = info.get("mtime", None)
+        if mtime is not None:
+            return mtime
+        raise RuntimeError("Could not retrieve modification time.")
+
+    @staticmethod
+    def _decode_stat(stat, parent_path=None):
+        if S_ISDIR(stat.st_mode):
+            t = "directory"
+        elif S_ISLNK(stat.st_mode):
+            t = "link"
+        else:
+            t = "file"
+        out = {
+            "name": "",
+            "size": stat.st_size,
+            "type": t,
+            "uid": stat.st_uid,
+            "gid": stat.st_gid,
+            "time": datetime.datetime.fromtimestamp(
+                stat.st_atime, tz=datetime.timezone.utc
+            ),
+            "mtime": datetime.datetime.fromtimestamp(
+                stat.st_mtime, tz=datetime.timezone.utc
+            ),
+        }
+        if parent_path:
+            out["name"] = "/".join([parent_path.rstrip("/"), stat.filename])
+        return out
+
+    def ls(self, path, detail=False):
+        path = self._strip_protocol(path)
+        logger.debug("Listing folder %s", path)
+        stats = [self._decode_stat(stat, path) for stat in self.ftp.listdir_iter(path)]
+        if detail:
+            return stats
+        else:
+            paths = [stat["name"] for stat in stats]
+            return sorted(paths)
+
+    def put_file(self, lpath, rpath, callback=None, **kwargs):
+        self.mkdirs(self._parent(os.fspath(rpath)), exist_ok=True)
+        logger.debug("Put file %s into %s", lpath, rpath)
+        self.ftp.put(lpath, rpath)
+
+    def get_file(self, rpath, lpath, **kwargs):
+        if self.isdir(rpath):
+            os.makedirs(lpath, exist_ok=True)
+        else:
+            self.ftp.get(self._strip_protocol(rpath), lpath)
+
+    def _open(self, path, mode="rb", block_size=None, **kwargs):
+        """
+        block_size: int or None
+            If 0, no buffering, if 1, line buffering, if >1, buffer that many
+            bytes, if None use default from paramiko.
+        """
+        logger.debug("Opening file %s", path)
+        if kwargs.get("autocommit", True) is False:
+            # writes to temporary file, move on commit
+            path2 = "/".join([self.temppath, str(uuid.uuid4())])
+            f = self.ftp.open(path2, mode, bufsize=block_size if block_size else -1)
+            f.temppath = path2
+            f.targetpath = path
+            f.fs = self
+            f.commit = types.MethodType(commit_a_file, f)
+            f.discard = types.MethodType(discard_a_file, f)
+        else:
+            f = self.ftp.open(path, mode, bufsize=block_size if block_size else -1)
+        return f
+
+    def _rm(self, path):
+        if self.isdir(path):
+            self.ftp.rmdir(path)
+        else:
+            self.ftp.remove(path)
+
+    def mv(self, old, new):
+        new = self._strip_protocol(new)
+        old = self._strip_protocol(old)
+        logger.debug("Renaming %s into %s", old, new)
+        self.ftp.posix_rename(old, new)
+
+
+def commit_a_file(self):
+    self.fs.mv(self.temppath, self.targetpath)
+
+
+def discard_a_file(self):
+    self.fs._rm(self.temppath)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/smb.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/smb.py
new file mode 100644
index 0000000000000000000000000000000000000000..db6b3f5c3702de90cf121ccca49f3ca2b580df9f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/smb.py
@@ -0,0 +1,416 @@
+"""
+This module contains SMBFileSystem class responsible for handling access to
+Windows Samba network shares by using package smbprotocol
+"""
+
+import datetime
+import re
+import uuid
+from stat import S_ISDIR, S_ISLNK
+
+import smbclient
+import smbprotocol.exceptions
+
+from .. import AbstractFileSystem
+from ..utils import infer_storage_options
+
+# ! pylint: disable=bad-continuation
+
+
+class SMBFileSystem(AbstractFileSystem):
+    """Allow reading and writing to Windows and Samba network shares.
+
+    When using `fsspec.open()` for getting a file-like object the URI
+    should be specified as this format:
+    ``smb://workgroup;user:password@server:port/share/folder/file.csv``.
+
+    Example::
+
+        >>> import fsspec
+        >>> with fsspec.open(
+        ...     'smb://myuser:mypassword@myserver.com/' 'share/folder/file.csv'
+        ... ) as smbfile:
+        ...     df = pd.read_csv(smbfile, sep='|', header=None)
+
+    Note that you need to pass in a valid hostname or IP address for the host
+    component of the URL. Do not use the Windows/NetBIOS machine name for the
+    host component.
+
+    The first component of the path in the URL points to the name of the shared
+    folder. Subsequent path components will point to the directory/folder/file.
+
+    The URL components ``workgroup`` , ``user``, ``password`` and ``port`` may be
+    optional.
+
+    .. note::
+
+        For working this source require `smbprotocol`_ to be installed, e.g.::
+
+            $ pip install smbprotocol
+            # or
+            # pip install smbprotocol[kerberos]
+
+    .. _smbprotocol: https://github.com/jborean93/smbprotocol#requirements
+
+    Note: if using this with the ``open`` or ``open_files``, with full URLs,
+    there is no way to tell if a path is relative, so all paths are assumed
+    to be absolute.
+    """
+
+    protocol = "smb"
+
+    # pylint: disable=too-many-arguments
+    def __init__(
+        self,
+        host,
+        port=None,
+        username=None,
+        password=None,
+        timeout=60,
+        encrypt=None,
+        share_access=None,
+        register_session_retries=4,
+        register_session_retry_wait=1,
+        register_session_retry_factor=10,
+        auto_mkdir=False,
+        **kwargs,
+    ):
+        """
+        You can use _get_kwargs_from_urls to get some kwargs from
+        a reasonable SMB url.
+
+        Authentication will be anonymous or integrated if username/password are not
+        given.
+
+        Parameters
+        ----------
+        host: str
+            The remote server name/ip to connect to
+        port: int or None
+            Port to connect with. Usually 445, sometimes 139.
+        username: str or None
+            Username to connect with. Required if Kerberos auth is not being used.
+        password: str or None
+            User's password on the server, if using username
+        timeout: int
+            Connection timeout in seconds
+        encrypt: bool
+            Whether to force encryption or not, once this has been set to True
+            the session cannot be changed back to False.
+        share_access: str or None
+            Specifies the default access applied to file open operations
+            performed with this file system object.
+            This affects whether other processes can concurrently open a handle
+            to the same file.
+
+            - None (the default): exclusively locks the file until closed.
+            - 'r': Allow other handles to be opened with read access.
+            - 'w': Allow other handles to be opened with write access.
+            - 'd': Allow other handles to be opened with delete access.
+        register_session_retries: int
+            Number of retries to register a session with the server. Retries are not performed
+            for authentication errors, as they are considered as invalid credentials and not network
+            issues. If set to negative value, no register attempts will be performed.
+        register_session_retry_wait: int
+            Time in seconds to wait between each retry. Number must be non-negative.
+        register_session_retry_factor: int
+            Base factor for the wait time between each retry. The wait time
+            is calculated using exponential function. For factor=1 all wait times
+            will be equal to `register_session_retry_wait`. For any number of retries,
+            the last wait time will be equal to `register_session_retry_wait` and for retries>1
+            the first wait time will be equal to `register_session_retry_wait / factor`.
+            Number must be equal to or greater than 1. Optimal factor is 10.
+        auto_mkdir: bool
+            Whether, when opening a file, the directory containing it should
+            be created (if it doesn't already exist). This is assumed by pyarrow
+            and zarr-python code.
+        """
+        super().__init__(**kwargs)
+        self.host = host
+        self.port = port
+        self.username = username
+        self.password = password
+        self.timeout = timeout
+        self.encrypt = encrypt
+        self.temppath = kwargs.pop("temppath", "")
+        self.share_access = share_access
+        self.register_session_retries = register_session_retries
+        if register_session_retry_wait < 0:
+            raise ValueError(
+                "register_session_retry_wait must be a non-negative integer"
+            )
+        self.register_session_retry_wait = register_session_retry_wait
+        if register_session_retry_factor < 1:
+            raise ValueError(
+                "register_session_retry_factor must be a positive "
+                "integer equal to or greater than 1"
+            )
+        self.register_session_retry_factor = register_session_retry_factor
+        self.auto_mkdir = auto_mkdir
+        self._connect()
+
+    @property
+    def _port(self):
+        return 445 if self.port is None else self.port
+
+    def _connect(self):
+        import time
+
+        if self.register_session_retries <= -1:
+            return
+
+        retried_errors = []
+
+        wait_time = self.register_session_retry_wait
+        n_waits = (
+            self.register_session_retries - 1
+        )  # -1 = No wait time after the last retry
+        factor = self.register_session_retry_factor
+
+        # Generate wait times for each retry attempt.
+        # Wait times are calculated using exponential function. For factor=1 all wait times
+        # will be equal to `wait`. For any number of retries the last wait time will be
+        # equal to `wait` and for retries>2 the first wait time will be equal to `wait / factor`.
+        wait_times = iter(
+            factor ** (n / n_waits - 1) * wait_time for n in range(0, n_waits + 1)
+        )
+
+        for attempt in range(self.register_session_retries + 1):
+            try:
+                smbclient.register_session(
+                    self.host,
+                    username=self.username,
+                    password=self.password,
+                    port=self._port,
+                    encrypt=self.encrypt,
+                    connection_timeout=self.timeout,
+                )
+                return
+            except (
+                smbprotocol.exceptions.SMBAuthenticationError,
+                smbprotocol.exceptions.LogonFailure,
+            ):
+                # These exceptions should not be repeated, as they clearly indicate
+                # that the credentials are invalid and not a network issue.
+                raise
+            except ValueError as exc:
+                if re.findall(r"\[Errno -\d+]", str(exc)):
+                    # This exception is raised by the smbprotocol.transport:Tcp.connect
+                    # and originates from socket.gaierror (OSError). These exceptions might
+                    # be raised due to network instability. We will retry to connect.
+                    retried_errors.append(exc)
+                else:
+                    # All another ValueError exceptions should be raised, as they are not
+                    # related to network issues.
+                    raise
+            except Exception as exc:
+                # Save the exception and retry to connect. This except might be dropped
+                # in the future, once all exceptions suited for retry are identified.
+                retried_errors.append(exc)
+
+            if attempt < self.register_session_retries:
+                time.sleep(next(wait_times))
+
+        # Raise last exception to inform user about the connection issues.
+        # Note: Should we use ExceptionGroup to raise all exceptions?
+        raise retried_errors[-1]
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        # smb://workgroup;user:password@host:port/share/folder/file.csv
+        out = infer_storage_options(path)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        return out
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        wpath = _as_unc_path(self.host, path)
+        if create_parents:
+            smbclient.makedirs(wpath, exist_ok=False, port=self._port, **kwargs)
+        else:
+            smbclient.mkdir(wpath, port=self._port, **kwargs)
+
+    def makedirs(self, path, exist_ok=False):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            smbclient.makedirs(wpath, exist_ok=exist_ok, port=self._port)
+
+    def rmdir(self, path):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            smbclient.rmdir(wpath, port=self._port)
+
+    def info(self, path, **kwargs):
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port, **kwargs)
+        if S_ISDIR(stats.st_mode):
+            stype = "directory"
+        elif S_ISLNK(stats.st_mode):
+            stype = "link"
+        else:
+            stype = "file"
+        res = {
+            "name": path + "/" if stype == "directory" else path,
+            "size": stats.st_size,
+            "type": stype,
+            "uid": stats.st_uid,
+            "gid": stats.st_gid,
+            "time": stats.st_atime,
+            "mtime": stats.st_mtime,
+        }
+        return res
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port)
+        return datetime.datetime.fromtimestamp(stats.st_ctime, tz=datetime.timezone.utc)
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        wpath = _as_unc_path(self.host, path)
+        stats = smbclient.stat(wpath, port=self._port)
+        return datetime.datetime.fromtimestamp(stats.st_mtime, tz=datetime.timezone.utc)
+
+    def ls(self, path, detail=True, **kwargs):
+        unc = _as_unc_path(self.host, path)
+        listed = smbclient.listdir(unc, port=self._port, **kwargs)
+        dirs = ["/".join([path.rstrip("/"), p]) for p in listed]
+        if detail:
+            dirs = [self.info(d) for d in dirs]
+        return dirs
+
+    # pylint: disable=too-many-arguments
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=-1,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """
+        block_size: int or None
+            If 0, no buffering, 1, line buffering, >1, buffer that many bytes
+
+        Notes
+        -----
+        By specifying 'share_access' in 'kwargs' it is possible to override the
+        default shared access setting applied in the constructor of this object.
+        """
+        if self.auto_mkdir and "w" in mode:
+            self.makedirs(self._parent(path), exist_ok=True)
+        bls = block_size if block_size is not None and block_size >= 0 else -1
+        wpath = _as_unc_path(self.host, path)
+        share_access = kwargs.pop("share_access", self.share_access)
+        if "w" in mode and autocommit is False:
+            temp = _as_temp_path(self.host, path, self.temppath)
+            return SMBFileOpener(
+                wpath, temp, mode, port=self._port, block_size=bls, **kwargs
+            )
+        return smbclient.open_file(
+            wpath,
+            mode,
+            buffering=bls,
+            share_access=share_access,
+            port=self._port,
+            **kwargs,
+        )
+
+    def copy(self, path1, path2, **kwargs):
+        """Copy within two locations in the same filesystem"""
+        wpath1 = _as_unc_path(self.host, path1)
+        wpath2 = _as_unc_path(self.host, path2)
+        if self.auto_mkdir:
+            self.makedirs(self._parent(path2), exist_ok=True)
+        smbclient.copyfile(wpath1, wpath2, port=self._port, **kwargs)
+
+    def _rm(self, path):
+        if _share_has_path(path):
+            wpath = _as_unc_path(self.host, path)
+            stats = smbclient.stat(wpath, port=self._port)
+            if S_ISDIR(stats.st_mode):
+                smbclient.rmdir(wpath, port=self._port)
+            else:
+                smbclient.remove(wpath, port=self._port)
+
+    def mv(self, path1, path2, recursive=None, maxdepth=None, **kwargs):
+        wpath1 = _as_unc_path(self.host, path1)
+        wpath2 = _as_unc_path(self.host, path2)
+        smbclient.rename(wpath1, wpath2, port=self._port, **kwargs)
+
+
+def _as_unc_path(host, path):
+    rpath = path.replace("/", "\\")
+    unc = f"\\\\{host}{rpath}"
+    return unc
+
+
+def _as_temp_path(host, path, temppath):
+    share = path.split("/")[1]
+    temp_file = f"/{share}{temppath}/{uuid.uuid4()}"
+    unc = _as_unc_path(host, temp_file)
+    return unc
+
+
+def _share_has_path(path):
+    parts = path.count("/")
+    if path.endswith("/"):
+        return parts > 2
+    return parts > 1
+
+
+class SMBFileOpener:
+    """writes to remote temporary file, move on commit"""
+
+    def __init__(self, path, temp, mode, port=445, block_size=-1, **kwargs):
+        self.path = path
+        self.temp = temp
+        self.mode = mode
+        self.block_size = block_size
+        self.kwargs = kwargs
+        self.smbfile = None
+        self._incontext = False
+        self.port = port
+        self._open()
+
+    def _open(self):
+        if self.smbfile is None or self.smbfile.closed:
+            self.smbfile = smbclient.open_file(
+                self.temp,
+                self.mode,
+                port=self.port,
+                buffering=self.block_size,
+                **self.kwargs,
+            )
+
+    def commit(self):
+        """Move temp file to definitive on success."""
+        # TODO: use transaction support in SMB protocol
+        smbclient.replace(self.temp, self.path, port=self.port)
+
+    def discard(self):
+        """Remove the temp file on failure."""
+        smbclient.remove(self.temp, port=self.port)
+
+    def __fspath__(self):
+        return self.path
+
+    def __iter__(self):
+        return self.smbfile.__iter__()
+
+    def __getattr__(self, item):
+        return getattr(self.smbfile, item)
+
+    def __enter__(self):
+        self._incontext = True
+        return self.smbfile.__enter__()
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._incontext = False
+        self.smbfile.__exit__(exc_type, exc_value, traceback)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/tar.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/tar.py
new file mode 100644
index 0000000000000000000000000000000000000000..52cfd871edc240afb9bdaec1632832cdaf823727
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/tar.py
@@ -0,0 +1,166 @@
+import logging
+import re
+import tarfile
+
+import fsspec
+from fsspec.archive import AbstractArchiveFileSystem
+from fsspec.compression import compr
+from fsspec.utils import infer_compression
+
+typemap = {b"0": "file", b"5": "directory"}
+
+logger = logging.getLogger("tar")
+
+
+class TarFileSystem(AbstractArchiveFileSystem):
+    """Compressed Tar archives as a file-system (read-only)
+
+    Supports the following formats:
+    tar.gz, tar.bz2, tar.xz
+    """
+
+    root_marker = ""
+    protocol = "tar"
+    cachable = False
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def __init__(
+        self,
+        fo="",
+        index_store=None,
+        target_options=None,
+        target_protocol=None,
+        compression=None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        target_options = target_options or {}
+
+        if isinstance(fo, str):
+            self.of = fsspec.open(fo, protocol=target_protocol, **target_options)
+            fo = self.of.open()  # keep the reference
+
+        # Try to infer compression.
+        if compression is None:
+            name = None
+
+            # Try different ways to get hold of the filename. `fo` might either
+            # be a `fsspec.LocalFileOpener`, an `io.BufferedReader` or an
+            # `fsspec.AbstractFileSystem` instance.
+            try:
+                # Amended io.BufferedReader or similar.
+                # This uses a "protocol extension" where original filenames are
+                # propagated to archive-like filesystems in order to let them
+                # infer the right compression appropriately.
+                if hasattr(fo, "original"):
+                    name = fo.original
+
+                # fsspec.LocalFileOpener
+                elif hasattr(fo, "path"):
+                    name = fo.path
+
+                # io.BufferedReader
+                elif hasattr(fo, "name"):
+                    name = fo.name
+
+                # fsspec.AbstractFileSystem
+                elif hasattr(fo, "info"):
+                    name = fo.info()["name"]
+
+            except Exception as ex:
+                logger.warning(
+                    f"Unable to determine file name, not inferring compression: {ex}"
+                )
+
+            if name is not None:
+                compression = infer_compression(name)
+                logger.info(f"Inferred compression {compression} from file name {name}")
+
+        if compression is not None:
+            # TODO: tarfile already implements compression with modes like "'r:gz'",
+            #  but then would seek to offset in the file work?
+            fo = compr[compression](fo)
+
+        self._fo_ref = fo
+        self.fo = fo  # the whole instance is a context
+        self.tar = tarfile.TarFile(fileobj=self.fo)
+        self.dir_cache = None
+
+        self.index_store = index_store
+        self.index = None
+        self._index()
+
+    def _index(self):
+        # TODO: load and set saved index, if exists
+        out = {}
+        for ti in self.tar:
+            info = ti.get_info()
+            info["type"] = typemap.get(info["type"], "file")
+            orig_name = info["name"].rstrip("/")
+            # Collapse duplicate slashes in the filesystem-facing name.
+            name = re.sub("/+", "/", orig_name)
+            info["name"] = name
+            if ti.islnk() or ti.issym():
+                # extractfile follows links, so report the size of the target
+                info["size"] = self._link_target_size(ti)
+            out[name] = (info, ti.offset_data, orig_name)
+
+        self.index = out
+        # TODO: save index to self.index_store here, if set
+
+    def _link_target_size(self, ti):
+        seen = set()
+        while ti.islnk() or ti.issym():
+            if ti.name in seen:
+                return 0
+            seen.add(ti.name)
+            try:
+                ti = self.tar._find_link_target(ti)
+            except KeyError:
+                # dangling link; opening it fails as well
+                return 0
+        return ti.size
+
+    def _get_dirs(self):
+        if self.dir_cache is not None:
+            return
+
+        # This enables ls to get directories as children as well as files
+        self.dir_cache = {
+            dirname: {"name": dirname, "size": 0, "type": "directory"}
+            for dirname in self._all_dirnames(self.index)
+        }
+        self.dir_cache.update(
+            {info["name"]: info for info, _, _ in self.index.values()}
+        )
+
+    def _open(self, path, mode="rb", **kwargs):
+        if mode != "rb":
+            raise ValueError("Read-only filesystem implementation")
+        # Accept paths containing the archive's duplicate slashes too.
+        path = re.sub("/+", "/", path)
+        try:
+            details, _, orig_name = self.index[path]
+        except KeyError as exc:
+            raise FileNotFoundError(path) from exc
+        if details["type"] != "file":
+            raise ValueError("Can only handle regular files")
+        out = self.tar.extractfile(orig_name)
+        # cat_file needs the size to resolve negative offsets, as zip provides.
+        out.size = details["size"]
+        return out
+
+    def close(self):
+        """Commits any write changes to the file. Done on ``del`` too."""
+        self.tar.close()
+
+    def __del__(self):
+        if hasattr(self, "tar"):
+            self.close()
+            del self.tar
+        if hasattr(self, "of") and hasattr(self.of, "__exit__"):
+            self.of.__exit__(None, None, None)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3048b6a3638cf34e400804a3057521e720b6e81
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/webhdfs.py
@@ -0,0 +1,503 @@
+# https://hadoop.apache.org/docs/r1.0.4/webhdfs.html
+
+import logging
+import os
+import secrets
+import shutil
+import tempfile
+import uuid
+from contextlib import suppress
+from datetime import datetime
+from urllib.parse import quote
+
+import requests
+
+from ..spec import AbstractBufferedFile, AbstractFileSystem
+from ..utils import infer_storage_options, tokenize
+
+logger = logging.getLogger("webhdfs")
+
+
+class WebHDFS(AbstractFileSystem):
+    """
+    Interface to HDFS over HTTP using the WebHDFS API. Supports also HttpFS gateways.
+
+    Four auth mechanisms are supported:
+
+    insecure: no auth is done, and the user is assumed to be whoever they
+        say they are (parameter ``user``), or a predefined value such as
+        "dr.who" if not given
+    spnego: when kerberos authentication is enabled, auth is negotiated by
+        requests_kerberos https://github.com/requests/requests-kerberos .
+        This establishes a session based on existing kinit login and/or
+        specified principal/password; parameters are passed with ``kerb_kwargs``
+    token: uses an existing Hadoop delegation token from another secured
+        service. Indeed, this client can also generate such tokens when
+        not insecure. Note that tokens expire, but can be renewed (by a
+        previously specified user) and may allow for proxying.
+    basic-auth: used when both parameter ``user`` and parameter ``password``
+        are provided.
+
+    """
+
+    tempdir = str(tempfile.gettempdir())
+    protocol = "webhdfs", "webHDFS"
+
+    def __init__(
+        self,
+        host,
+        port=50070,
+        kerberos=False,
+        token=None,
+        user=None,
+        password=None,
+        proxy_to=None,
+        kerb_kwargs=None,
+        data_proxy=None,
+        use_https=False,
+        session_cert=None,
+        session_verify=True,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        host: str
+            Name-node address
+        port: int
+            Port for webHDFS
+        kerberos: bool
+            Whether to authenticate with kerberos for this connection
+        token: str or None
+            If given, use this token on every call to authenticate. A user
+            and user-proxy may be encoded in the token and should not be also
+            given
+        user: str or None
+            If given, assert the user name to connect with
+        password: str or None
+            If given, assert the password to use for basic auth. If password
+            is provided, user must be provided also
+        proxy_to: str or None
+            If given, the user has the authority to proxy, and this value is
+            the user in who's name actions are taken
+        kerb_kwargs: dict
+            Any extra arguments for HTTPKerberosAuth, see
+            `<https://github.com/requests/requests-kerberos/blob/master/requests_kerberos/kerberos_.py>`_
+        data_proxy: dict, callable or None
+            If given, map data-node addresses. This can be necessary if the
+            HDFS cluster is behind a proxy, running on Docker or otherwise has
+            a mismatch between the host-names given by the name-node and the
+            address by which to refer to them from the client. If a dict,
+            maps host names ``host->data_proxy[host]``; if a callable, full
+            URLs are passed, and function must conform to
+            ``url->data_proxy(url)``.
+        use_https: bool
+            Whether to connect to the Name-node using HTTPS instead of HTTP
+        session_cert: str or Tuple[str, str] or None
+            Path to a certificate file, or tuple of (cert, key) files to use
+            for the requests.Session
+        session_verify: str, bool or None
+            Path to a certificate file to use for verifying the requests.Session.
+        kwargs
+        """
+        if self._cached:
+            return
+        super().__init__(**kwargs)
+        self.url = f"{'https' if use_https else 'http'}://{host}:{port}/webhdfs/v1"
+        self.kerb = kerberos
+        self.kerb_kwargs = kerb_kwargs or {}
+        self.pars = {}
+        self.proxy = data_proxy or {}
+        if token is not None:
+            if user is not None or proxy_to is not None:
+                raise ValueError(
+                    "If passing a delegation token, must not set "
+                    "user or proxy_to, as these are encoded in the"
+                    " token"
+                )
+            self.pars["delegation"] = token
+        self.user = user
+        self.password = password
+
+        if password is not None:
+            if user is None:
+                raise ValueError(
+                    "If passing a password, the user must also be"
+                    "set in order to set up the basic-auth"
+                )
+        else:
+            if user is not None:
+                self.pars["user.name"] = user
+
+        if proxy_to is not None:
+            self.pars["doas"] = proxy_to
+        if kerberos and user is not None:
+            raise ValueError(
+                "If using Kerberos auth, do not specify the "
+                "user, this is handled by kinit."
+            )
+
+        self.session_cert = session_cert
+        self.session_verify = session_verify
+
+        self._connect()
+
+        self._fsid = f"webhdfs_{tokenize(host, port)}"
+
+    @property
+    def fsid(self):
+        return self._fsid
+
+    def _connect(self):
+        self.session = requests.Session()
+
+        if self.session_cert:
+            self.session.cert = self.session_cert
+
+        self.session.verify = self.session_verify
+
+        if self.kerb:
+            from requests_kerberos import HTTPKerberosAuth
+
+            self.session.auth = HTTPKerberosAuth(**self.kerb_kwargs)
+
+        if self.user is not None and self.password is not None:
+            from requests.auth import HTTPBasicAuth
+
+            self.session.auth = HTTPBasicAuth(self.user, self.password)
+
+    def _call(self, op, method="get", path=None, data=None, redirect=True, **kwargs):
+        path = self._strip_protocol(path) if path is not None else ""
+        url = self._apply_proxy(self.url + quote(path, safe="/="))
+        args = kwargs.copy()
+        args.update(self.pars)
+        args["op"] = op.upper()
+        logger.debug("sending %s with %s", url, method)
+        out = self.session.request(
+            method=method.upper(),
+            url=url,
+            params=args,
+            data=data,
+            allow_redirects=redirect,
+        )
+        if out.status_code in [400, 401, 403, 404, 500]:
+            try:
+                err = out.json()
+                msg = err["RemoteException"]["message"]
+                exp = err["RemoteException"]["exception"]
+            except (ValueError, KeyError):
+                pass
+            else:
+                if exp in ["IllegalArgumentException", "UnsupportedOperationException"]:
+                    raise ValueError(msg)
+                elif exp in ["SecurityException", "AccessControlException"]:
+                    raise PermissionError(msg)
+                elif exp in ["FileNotFoundException"]:
+                    raise FileNotFoundError(msg)
+                else:
+                    raise RuntimeError(msg)
+        out.raise_for_status()
+        return out
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        replication=None,
+        permissions=None,
+        **kwargs,
+    ):
+        """
+
+        Parameters
+        ----------
+        path: str
+            File location
+        mode: str
+            'rb', 'wb', etc.
+        block_size: int
+            Client buffer size for read-ahead or write buffer
+        autocommit: bool
+            If False, writes to temporary file that only gets put in final
+            location upon commit
+        replication: int
+            Number of copies of file on the cluster, write mode only
+        permissions: str or int
+            posix permissions, write mode only
+        kwargs
+
+        Returns
+        -------
+        WebHDFile instance
+        """
+        block_size = block_size or self.blocksize
+        return WebHDFile(
+            self,
+            path,
+            mode=mode,
+            block_size=block_size,
+            tempdir=self.tempdir,
+            autocommit=autocommit,
+            replication=replication,
+            permissions=permissions,
+        )
+
+    @staticmethod
+    def _process_info(info):
+        info["type"] = info["type"].lower()
+        info["size"] = info["length"]
+        return info
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        return infer_storage_options(path)["path"]
+
+    @staticmethod
+    def _get_kwargs_from_urls(urlpath):
+        out = infer_storage_options(urlpath)
+        out.pop("path", None)
+        out.pop("protocol", None)
+        if "username" in out:
+            out["user"] = out.pop("username")
+        return out
+
+    def info(self, path):
+        out = self._call("GETFILESTATUS", path=path)
+        info = out.json()["FileStatus"]
+        info["name"] = path
+        return self._process_info(info)
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        # The API does not provide creation time, so we use modification time
+        info = self.info(path)
+        mtime = info.get("modificationTime", None)
+        if mtime is not None:
+            return datetime.fromtimestamp(mtime / 1000)
+        raise RuntimeError("Could not retrieve creation time (modification time).")
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        info = self.info(path)
+        mtime = info.get("modificationTime", None)
+        if mtime is not None:
+            return datetime.fromtimestamp(mtime / 1000)
+        raise RuntimeError("Could not retrieve modification time.")
+
+    def ls(self, path, detail=False, **kwargs):
+        out = self._call("LISTSTATUS", path=path)
+        infos = out.json()["FileStatuses"]["FileStatus"]
+        for info in infos:
+            self._process_info(info)
+            info["name"] = path.rstrip("/") + "/" + info["pathSuffix"]
+        if detail:
+            return sorted(infos, key=lambda i: i["name"])
+        else:
+            return sorted(info["name"] for info in infos)
+
+    def content_summary(self, path):
+        """Total numbers of files, directories and bytes under path"""
+        out = self._call("GETCONTENTSUMMARY", path=path)
+        return out.json()["ContentSummary"]
+
+    def ukey(self, path):
+        """Checksum info of file, giving method and result"""
+        out = self._call("GETFILECHECKSUM", path=path, redirect=False)
+        if "Location" in out.headers:
+            location = self._apply_proxy(out.headers["Location"])
+            out2 = self.session.get(location)
+            out2.raise_for_status()
+            return out2.json()["FileChecksum"]
+        else:
+            out.raise_for_status()
+            return out.json()["FileChecksum"]
+
+    def home_directory(self):
+        """Get user's home directory"""
+        out = self._call("GETHOMEDIRECTORY")
+        return out.json()["Path"]
+
+    def get_delegation_token(self, renewer=None):
+        """Retrieve token which can give the same authority to other uses
+
+        Parameters
+        ----------
+        renewer: str or None
+            User who may use this token; if None, will be current user
+        """
+        if renewer:
+            out = self._call("GETDELEGATIONTOKEN", renewer=renewer)
+        else:
+            out = self._call("GETDELEGATIONTOKEN")
+        t = out.json()["Token"]
+        if t is None:
+            raise ValueError("No token available for this user/security context")
+        return t["urlString"]
+
+    def renew_delegation_token(self, token):
+        """Make token live longer. Returns new expiry time"""
+        out = self._call("RENEWDELEGATIONTOKEN", method="put", token=token)
+        return out.json()["long"]
+
+    def cancel_delegation_token(self, token):
+        """Stop the token from being useful"""
+        self._call("CANCELDELEGATIONTOKEN", method="put", token=token)
+
+    def chmod(self, path, mod):
+        """Set the permission at path
+
+        Parameters
+        ----------
+        path: str
+            location to set (file or directory)
+        mod: str or int
+            posix epresentation or permission, give as oct string, e.g, '777'
+            or 0o777
+        """
+        self._call("SETPERMISSION", method="put", path=path, permission=mod)
+
+    def chown(self, path, owner=None, group=None):
+        """Change owning user and/or group"""
+        kwargs = {}
+        if owner is not None:
+            kwargs["owner"] = owner
+        if group is not None:
+            kwargs["group"] = group
+        self._call("SETOWNER", method="put", path=path, **kwargs)
+
+    def set_replication(self, path, replication):
+        """
+        Set file replication factor
+
+        Parameters
+        ----------
+        path: str
+            File location (not for directories)
+        replication: int
+            Number of copies of file on the cluster. Should be smaller than
+            number of data nodes; normally 3 on most systems.
+        """
+        self._call("SETREPLICATION", path=path, method="put", replication=replication)
+
+    def mkdir(self, path, **kwargs):
+        self._call("MKDIRS", method="put", path=path)
+
+    def makedirs(self, path, exist_ok=False):
+        if exist_ok is False and self.exists(path):
+            raise FileExistsError(path)
+        self.mkdir(path)
+
+    def mv(self, path1, path2, **kwargs):
+        self._call("RENAME", method="put", path=path1, destination=path2)
+
+    def rm(self, path, recursive=False, **kwargs):
+        self._call(
+            "DELETE",
+            method="delete",
+            path=path,
+            recursive="true" if recursive else "false",
+        )
+
+    def rm_file(self, path, **kwargs):
+        self.rm(path)
+
+    def cp_file(self, lpath, rpath, **kwargs):
+        with self.open(lpath) as lstream:
+            tmp_fname = "/".join([self._parent(rpath), f".tmp.{secrets.token_hex(16)}"])
+            # Perform an atomic copy (stream to a temporary file and
+            # move it to the actual destination).
+            try:
+                with self.open(tmp_fname, "wb") as rstream:
+                    shutil.copyfileobj(lstream, rstream)
+                self.mv(tmp_fname, rpath)
+            except BaseException:
+                with suppress(FileNotFoundError):
+                    self.rm(tmp_fname)
+                raise
+
+    def _apply_proxy(self, location):
+        if self.proxy and callable(self.proxy):
+            location = self.proxy(location)
+        elif self.proxy:
+            # as a dict
+            for k, v in self.proxy.items():
+                location = location.replace(k, v, 1)
+        return location
+
+
+class WebHDFile(AbstractBufferedFile):
+    """A file living in HDFS over webHDFS"""
+
+    def __init__(self, fs, path, **kwargs):
+        super().__init__(fs, path, **kwargs)
+        kwargs = kwargs.copy()
+        if kwargs.get("permissions", None) is None:
+            kwargs.pop("permissions", None)
+        if kwargs.get("replication", None) is None:
+            kwargs.pop("replication", None)
+        self.permissions = kwargs.pop("permissions", 511)
+        tempdir = kwargs.pop("tempdir")
+        if kwargs.pop("autocommit", False) is False:
+            self.target = self.path
+            self.path = os.path.join(tempdir, str(uuid.uuid4()))
+
+    def _upload_chunk(self, final=False):
+        """Write one part of a multi-block file upload
+
+        Parameters
+        ==========
+        final: bool
+            This is the last block, so should complete file, if
+            self.autocommit is True.
+        """
+        out = self.fs.session.post(
+            self.location,
+            data=self.buffer.getvalue(),
+            headers={"content-type": "application/octet-stream"},
+        )
+        out.raise_for_status()
+        return True
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        kwargs = self.kwargs.copy()
+        if "a" in self.mode:
+            op, method = "APPEND", "POST"
+        else:
+            op, method = "CREATE", "PUT"
+            kwargs["overwrite"] = "true"
+        out = self.fs._call(op, method, self.path, redirect=False, **kwargs)
+        location = self.fs._apply_proxy(out.headers["Location"])
+        if "w" in self.mode:
+            # create empty file to append to
+            out2 = self.fs.session.put(
+                location, headers={"content-type": "application/octet-stream"}
+            )
+            out2.raise_for_status()
+            # after creating empty file, change location to append to
+            out2 = self.fs._call("APPEND", "POST", self.path, redirect=False, **kwargs)
+            self.location = self.fs._apply_proxy(out2.headers["Location"])
+
+    def _fetch_range(self, start, end):
+        start = max(start, 0)
+        end = min(self.size, end)
+        if start >= end or start >= self.size:
+            return b""
+        out = self.fs._call(
+            "OPEN", path=self.path, offset=start, length=end - start, redirect=False
+        )
+        out.raise_for_status()
+        if "Location" in out.headers:
+            location = out.headers["Location"]
+            out2 = self.fs.session.get(self.fs._apply_proxy(location))
+            return out2.content
+        else:
+            return out.content
+
+    def commit(self):
+        self.fs.mv(self.path, self.target)
+
+    def discard(self):
+        self.fs.rm(self.path)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/zip.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/zip.py
new file mode 100644
index 0000000000000000000000000000000000000000..a47ef188935bba2b3a29ab59c1b8606763736bcc
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/implementations/zip.py
@@ -0,0 +1,194 @@
+import os
+import zipfile
+
+import fsspec
+from fsspec.archive import AbstractArchiveFileSystem
+
+
+class ZipFileSystem(AbstractArchiveFileSystem):
+    """Read/Write contents of ZIP archive as a file-system
+
+    Keeps file object open while instance lives.
+
+    This class is pickleable, but not necessarily thread-safe
+    """
+
+    root_marker = ""
+    protocol = "zip"
+    cachable = False
+
+    def __init__(
+        self,
+        fo="",
+        mode="r",
+        target_protocol=None,
+        target_options=None,
+        compression=zipfile.ZIP_STORED,
+        allowZip64=True,
+        compresslevel=None,
+        **kwargs,
+    ):
+        """
+        Parameters
+        ----------
+        fo: str or file-like
+            Contains ZIP. In append mode, a missing archive is created.
+            If a str, will fetch file using
+            :meth:`~fsspec.open_files`, which must return one file exactly.
+        mode: str
+            Accept: "r", "w", "a"
+        target_protocol: str (optional)
+            If ``fo`` is a string, this value can be used to override the
+            FS protocol inferred from a URL
+        target_options: dict (optional)
+            Kwargs passed when instantiating the target FS, if ``fo`` is
+            a string.
+        compression, allowZip64, compresslevel: passed to ZipFile
+            Only relevant when creating a ZIP
+        """
+        super().__init__(self, **kwargs)
+        if mode not in set("rwa"):
+            raise ValueError(f"mode '{mode}' no understood")
+        self.mode = mode
+        if isinstance(fo, (str, os.PathLike)):
+            if mode == "a":
+                m = "r+b"
+            else:
+                m = mode + "b"
+            fo = fsspec.open(
+                fo, mode=m, protocol=target_protocol, **(target_options or {})
+            )
+        self.force_zip_64 = allowZip64
+        self.of = fo
+        try:
+            self.fo = fo.__enter__()  # the whole instance is a context
+        except FileNotFoundError:
+            if mode != "a" or not isinstance(fo, fsspec.core.OpenFile):
+                raise
+            fo.mode = "w+b"
+            self.fo = fo.__enter__()
+        self.zip = zipfile.ZipFile(
+            self.fo,
+            mode=mode,
+            compression=compression,
+            allowZip64=allowZip64,
+            compresslevel=compresslevel,
+        )
+        self.dir_cache = None
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        # zip file paths are always relative to the archive root
+        return super()._strip_protocol(path).lstrip("/")
+
+    def __del__(self):
+        if hasattr(self, "zip"):
+            self.close()
+            del self.zip
+        if hasattr(self, "of") and hasattr(self.of, "__exit__"):
+            self.of.__exit__(None, None, None)
+
+    def close(self):
+        """Commits any write changes to the file. Done on ``del`` too."""
+        self.zip.close()
+
+    def _get_dirs(self):
+        if self.dir_cache is None or self.mode in set("wa"):
+            # when writing, dir_cache is always in the ZipFile's attributes,
+            # not read from the file.
+            files = self.zip.infolist()
+            self.dir_cache = {
+                dirname.rstrip("/"): {
+                    "name": dirname.rstrip("/"),
+                    "size": 0,
+                    "type": "directory",
+                }
+                for dirname in self._all_dirnames(self.zip.namelist())
+            }
+            for z in files:
+                f = {s: getattr(z, s, None) for s in zipfile.ZipInfo.__slots__}
+                f.update(
+                    {
+                        "name": z.filename.rstrip("/"),
+                        "size": z.file_size,
+                        "type": ("directory" if z.is_dir() else "file"),
+                    }
+                )
+                self.dir_cache[f["name"]] = f
+
+    def pipe_file(self, path, value, **kwargs):
+        # override upstream, because we know the exact file size in this case
+        path = self._strip_protocol(path)
+        self.zip.writestr(path, value, **kwargs)
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        path = self._strip_protocol(path)
+        if "r" in mode and self.mode in set("wa"):
+            if self.exists(path):
+                raise OSError("ZipFS can only be open for reading or writing, not both")
+            raise FileNotFoundError(path)
+        if "r" in self.mode and "w" in mode:
+            raise OSError("ZipFS can only be open for reading or writing, not both")
+        try:
+            out = self.zip.open(path, mode.strip("b"), force_zip64=self.force_zip_64)
+        except KeyError as exc:
+            # zipfile reports a missing member as KeyError; fsspec callers,
+            # including FSMap's missing_exceptions, expect FileNotFoundError.
+            raise FileNotFoundError(path) from exc
+        if "r" in mode:
+            info = self.info(path)
+            out.size = info["size"]
+            out.name = info["name"]
+        return out
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        def to_parts(_path: str):
+            return list(filter(None, _path.replace("\\", "/").split("/")))
+
+        if not isinstance(path, str):
+            path = str(path)
+
+        path = self._strip_protocol(path)
+        path_parts = to_parts(path)
+        path_depth = len(path_parts)
+
+        self._get_dirs()
+
+        result = {}
+        # To match posix find, if an exact file name is given, we should
+        # return only that file
+        if path in self.dir_cache and self.dir_cache[path]["type"] == "file":
+            result[path] = self.dir_cache[path]
+            return result if detail else [path]
+
+        for file_path, file_info in self.dir_cache.items():
+            if len(file_parts := to_parts(file_path)) < path_depth or any(
+                a != b for a, b in zip(path_parts, file_parts)
+            ):
+                # skip parent folders and mismatching paths
+                continue
+
+            if file_info["type"] == "directory":
+                if withdirs and file_path not in result:
+                    result[file_path.strip("/")] = file_info
+                continue
+
+            if file_path not in result:
+                result[file_path] = file_info if detail else None
+
+        if maxdepth:
+            result = {
+                k: v for k, v in result.items() if k.count("/") < maxdepth + path_depth
+            }
+        return result if detail else sorted(result)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/json.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/json.py
new file mode 100644
index 0000000000000000000000000000000000000000..5c53a24913d0b28f4b53a163b97ff8f58abeb031
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/json.py
@@ -0,0 +1,112 @@
+import json
+from collections.abc import Callable, Mapping, Sequence
+from contextlib import suppress
+from pathlib import PurePath
+from typing import Any, ClassVar
+
+from .registry import _import_class, get_filesystem_class
+from .spec import AbstractFileSystem
+
+
+class FilesystemJSONEncoder(json.JSONEncoder):
+    include_password: ClassVar[bool] = True
+
+    def default(self, o: Any) -> Any:
+        if isinstance(o, AbstractFileSystem):
+            return o.to_dict(include_password=self.include_password)
+        if isinstance(o, PurePath):
+            cls = type(o)
+            return {"cls": f"{cls.__module__}.{cls.__name__}", "str": str(o)}
+
+        return super().default(o)
+
+    def make_serializable(self, obj: Any) -> Any:
+        """
+        Recursively converts an object so that it can be JSON serialized via
+        :func:`json.dumps` and :func:`json.dump`, without actually calling
+        said functions.
+        """
+        if isinstance(obj, (str, int, float, bool)):
+            return obj
+        if isinstance(obj, Mapping):
+            return {k: self.make_serializable(v) for k, v in obj.items()}
+        if isinstance(obj, Sequence):
+            return [self.make_serializable(v) for v in obj]
+
+        return self.default(obj)
+
+
+class FilesystemJSONDecoder(json.JSONDecoder):
+    def __init__(
+        self,
+        *,
+        object_hook: Callable[[dict[str, Any]], Any] | None = None,
+        parse_float: Callable[[str], Any] | None = None,
+        parse_int: Callable[[str], Any] | None = None,
+        parse_constant: Callable[[str], Any] | None = None,
+        strict: bool = True,
+        object_pairs_hook: Callable[[list[tuple[str, Any]]], Any] | None = None,
+    ) -> None:
+        self.original_object_hook = object_hook
+
+        super().__init__(
+            object_hook=self.custom_object_hook,
+            parse_float=parse_float,
+            parse_int=parse_int,
+            parse_constant=parse_constant,
+            strict=strict,
+            object_pairs_hook=object_pairs_hook,
+        )
+
+    @classmethod
+    def try_resolve_path_cls(cls, dct: dict[str, Any]):
+        with suppress(Exception):
+            fqp = dct["cls"]
+
+            path_cls = _import_class(fqp)
+
+            if issubclass(path_cls, PurePath):
+                return path_cls
+
+        return None
+
+    @classmethod
+    def try_resolve_fs_cls(cls, dct: dict[str, Any]):
+        with suppress(Exception):
+            if "cls" in dct:
+                try:
+                    fs_cls = _import_class(dct["cls"])
+                    if issubclass(fs_cls, AbstractFileSystem):
+                        return fs_cls
+                except Exception:
+                    if "protocol" in dct:  # Fallback if cls cannot be imported
+                        return get_filesystem_class(dct["protocol"])
+
+                    raise
+
+        return None
+
+    def custom_object_hook(self, dct: dict[str, Any]):
+        if "cls" in dct:
+            if (obj_cls := self.try_resolve_fs_cls(dct)) is not None:
+                return AbstractFileSystem.from_dict(dct)
+            if (obj_cls := self.try_resolve_path_cls(dct)) is not None:
+                return obj_cls(dct["str"])
+
+        if self.original_object_hook is not None:
+            return self.original_object_hook(dct)
+
+        return dct
+
+    def unmake_serializable(self, obj: Any) -> Any:
+        """
+        Inverse function of :meth:`FilesystemJSONEncoder.make_serializable`.
+        """
+        if isinstance(obj, dict):
+            obj = self.custom_object_hook(obj)
+        if isinstance(obj, dict):
+            return {k: self.unmake_serializable(v) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [self.unmake_serializable(v) for v in obj]
+
+        return obj
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/mapping.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/mapping.py
new file mode 100644
index 0000000000000000000000000000000000000000..41386ff30e827581563de87df562d88832eedf7c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/mapping.py
@@ -0,0 +1,259 @@
+import array
+import logging
+import posixpath
+import uuid
+import warnings
+from collections.abc import MutableMapping
+from functools import cached_property
+
+from fsspec.core import url_to_fs
+
+logger = logging.getLogger("fsspec.mapping")
+_MISSING = object()
+
+
+class FSMap(MutableMapping):
+    """Wrap a FileSystem instance as a mutable wrapping.
+
+    The keys of the mapping become files under the given root, and the
+    values (which must be bytes) the contents of those files.
+
+    Parameters
+    ----------
+    root: string
+        prefix for all the files
+    fs: FileSystem instance
+    check: bool (=True)
+        performs a touch at the location, to check for write access.
+
+    Examples
+    --------
+    >>> fs = FileSystem(**parameters)  # doctest: +SKIP
+    >>> d = FSMap('my-data/path/', fs)  # doctest: +SKIP
+    or, more likely
+    >>> d = fs.get_mapper('my-data/path/')
+
+    >>> d['loc1'] = b'Hello World'  # doctest: +SKIP
+    >>> list(d.keys())  # doctest: +SKIP
+    ['loc1']
+    >>> d['loc1']  # doctest: +SKIP
+    b'Hello World'
+    """
+
+    def __init__(self, root, fs, check=False, create=False, missing_exceptions=None):
+        self.fs = fs
+        self.root = fs._strip_protocol(root)
+        self._root_key_to_str = fs._strip_protocol(posixpath.join(root, "x"))[:-1]
+        if missing_exceptions is None:
+            missing_exceptions = (
+                FileNotFoundError,
+                IsADirectoryError,
+                NotADirectoryError,
+            )
+        self.missing_exceptions = missing_exceptions
+        self.check = check
+        self.create = create
+        if create:
+            if not self.fs.exists(root):
+                self.fs.mkdir(root)
+        if check:
+            if not self.fs.exists(root):
+                raise ValueError(
+                    f"Path {root} does not exist. Create "
+                    f" with the ``create=True`` keyword"
+                )
+            check_path = f"{root}/{uuid.uuid4().hex}"
+            self.fs.touch(check_path)
+            self.fs.rm(check_path)
+
+    @cached_property
+    def dirfs(self):
+        """dirfs instance that can be used with the same keys as the mapper"""
+        from .implementations.dirfs import DirFileSystem
+
+        return DirFileSystem(path=self._root_key_to_str, fs=self.fs)
+
+    def clear(self):
+        """Remove all keys below root - empties out mapping"""
+        logger.info("Clear mapping at %s", self.root)
+        try:
+            self.fs.rm(self.root, True)
+            self.fs.mkdir(self.root)
+        except:  # noqa: E722
+            pass
+
+    def getitems(self, keys, on_error="raise"):
+        """Fetch multiple items from the store
+
+        If the backend is async-able, this might proceed concurrently
+
+        Parameters
+        ----------
+        keys: list(str)
+            They keys to be fetched
+        on_error : "raise", "omit", "return"
+            If raise, an underlying exception will be raised (converted to KeyError
+            if the type is in self.missing_exceptions); if omit, keys with exception
+            will simply not be included in the output; if "return", all keys are
+            included in the output, but the value will be bytes or an exception
+            instance.
+
+        Returns
+        -------
+        dict(key, bytes|exception)
+        """
+        keys2 = [self._key_to_str(k) for k in keys]
+        oe = on_error if on_error == "raise" else "return"
+        try:
+            out = self.fs.cat(keys2, on_error=oe)
+            if isinstance(out, bytes):
+                out = {keys2[0]: out}
+        except self.missing_exceptions as e:
+            raise KeyError from e
+        out = {
+            k: (KeyError() if isinstance(v, self.missing_exceptions) else v)
+            for k, v in out.items()
+        }
+        return {
+            key: out[k2] if on_error == "raise" else out.get(k2, KeyError(k2))
+            for key, k2 in zip(keys, keys2)
+            if on_error == "return" or not isinstance(out[k2], BaseException)
+        }
+
+    def setitems(self, values_dict):
+        """Set the values of multiple items in the store
+
+        Parameters
+        ----------
+        values_dict: dict(str, bytes)
+        """
+        values = {self._key_to_str(k): maybe_convert(v) for k, v in values_dict.items()}
+        self.fs.pipe(values)
+
+    def delitems(self, keys):
+        """Remove multiple keys from the store"""
+        self.fs.rm([self._key_to_str(k) for k in keys])
+
+    def _key_to_str(self, key):
+        """Generate full path for the key"""
+        if not isinstance(key, str):
+            # raise TypeError("key must be of type `str`, got `{type(key).__name__}`"
+            warnings.warn(
+                "from fsspec 2023.5 onward FSMap non-str keys will raise TypeError",
+                DeprecationWarning,
+            )
+            if isinstance(key, list):
+                key = tuple(key)
+            key = str(key)
+        return f"{self._root_key_to_str}{key}".rstrip("/")
+
+    def _str_to_key(self, s):
+        """Strip path of to leave key name"""
+        return s[len(self.root) :].lstrip("/")
+
+    def __getitem__(self, key, default=None):
+        """Retrieve data"""
+        k = self._key_to_str(key)
+        try:
+            result = self.fs.cat(k)
+        except self.missing_exceptions as exc:
+            if default is not None:
+                return default
+            raise KeyError(key) from exc
+        return result
+
+    def pop(self, key, default=_MISSING):
+        """Pop data"""
+        try:
+            result = self[key]
+        except KeyError:
+            if default is _MISSING:
+                raise
+            return default
+        try:
+            del self[key]
+        except KeyError:
+            pass
+        return result
+
+    def __setitem__(self, key, value):
+        """Store value in key"""
+        key = self._key_to_str(key)
+        self.fs.mkdirs(self.fs._parent(key), exist_ok=True)
+        self.fs.pipe_file(key, maybe_convert(value))
+
+    def __iter__(self):
+        return (self._str_to_key(x) for x in self.fs.find(self.root))
+
+    def __len__(self):
+        return len(self.fs.find(self.root))
+
+    def __delitem__(self, key):
+        """Remove key"""
+        try:
+            self.fs.rm(self._key_to_str(key))
+        except Exception as exc:
+            raise KeyError from exc
+
+    def __contains__(self, key):
+        """Does key exist in mapping?"""
+        path = self._key_to_str(key)
+        return self.fs.isfile(path)
+
+    def __reduce__(self):
+        return FSMap, (self.root, self.fs, False, False, self.missing_exceptions)
+
+
+def maybe_convert(value):
+    if isinstance(value, array.array) or hasattr(value, "__array__"):
+        # bytes-like things
+        if hasattr(value, "dtype") and value.dtype.kind in "Mm":
+            # The buffer interface doesn't support datetime64/timdelta64 numpy
+            # arrays
+            value = value.view("int64")
+        value = bytes(memoryview(value))
+    return value
+
+
+def get_mapper(
+    url="",
+    check=False,
+    create=False,
+    missing_exceptions=None,
+    alternate_root=None,
+    **kwargs,
+):
+    """Create key-value interface for given URL and options
+
+    The URL will be of the form "protocol://location" and point to the root
+    of the mapper required. All keys will be file-names below this location,
+    and their values the contents of each key.
+
+    Also accepts compound URLs like zip::s3://bucket/file.zip , see ``fsspec.open``.
+
+    Parameters
+    ----------
+    url: str
+        Root URL of mapping
+    check: bool
+        Whether to attempt to read from the location before instantiation, to
+        check that the mapping does exist
+    create: bool
+        Whether to make the directory corresponding to the root before
+        instantiating
+    missing_exceptions: None or tuple
+        If given, these exception types will be regarded as missing keys and
+        return KeyError when trying to read data. By default, you get
+        (FileNotFoundError, IsADirectoryError, NotADirectoryError)
+    alternate_root: None or str
+        In cases of complex URLs, the parser may fail to pick the correct part
+        for the mapper root, so this arg can override
+
+    Returns
+    -------
+    ``FSMap`` instance, the dict-like key-value store.
+    """
+    # Removing protocol here - could defer to each open() on the backend
+    fs, urlpath = url_to_fs(url, **kwargs)
+    root = alternate_root if alternate_root is not None else urlpath
+    return FSMap(root, fs, check, create, missing_exceptions=missing_exceptions)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/parquet.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/parquet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e6e03fb14f9ec9224804a2ccb77bb84fe3390952
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/parquet.py
@@ -0,0 +1,572 @@
+import io
+import json
+import warnings
+
+import fsspec
+
+from .core import url_to_fs
+from .spec import AbstractBufferedFile
+from .utils import merge_offset_ranges
+
+# Parquet-Specific Utilities for fsspec
+#
+# Most of the functions defined in this module are NOT
+# intended for public consumption. The only exception
+# to this is `open_parquet_file`, which should be used
+# place of `fs.open()` to open parquet-formatted files
+# on remote file systems.
+
+
+class AlreadyBufferedFile(AbstractBufferedFile):
+    def _fetch_range(self, start, end):
+        raise NotImplementedError
+
+
+def open_parquet_files(
+    path: list[str],
+    fs: None | fsspec.AbstractFileSystem = None,
+    metadata=None,
+    columns: None | list[str] = None,
+    row_groups: None | list[int] = None,
+    storage_options: None | dict = None,
+    engine: str = "auto",
+    max_gap: int = 64_000,
+    max_block: int = 256_000_000,
+    footer_sample_size: int = 1_000_000,
+    filters: None | list[list[list[str]]] = None,
+    **kwargs,
+):
+    """
+    Return a file-like object for a single Parquet file.
+
+    The specified parquet `engine` will be used to parse the
+    footer metadata, and determine the required byte ranges
+    from the file. The target path will then be opened with
+    the "parts" (`KnownPartsOfAFile`) caching strategy.
+
+    Note that this method is intended for usage with remote
+    file systems, and is unlikely to improve parquet-read
+    performance on local file systems.
+
+    Parameters
+    ----------
+    path: str
+        Target file path.
+    metadata: Any, optional
+        Parquet metadata object. Object type must be supported
+        by the backend parquet engine. For now, only the "fastparquet"
+        engine supports an explicit `ParquetFile` metadata object.
+        If a metadata object is supplied, the remote footer metadata
+        will not need to be transferred into local memory.
+    fs: AbstractFileSystem, optional
+        Filesystem object to use for opening the file. If nothing is
+        specified, an `AbstractFileSystem` object will be inferred.
+    engine : str, default "auto"
+        Parquet engine to use for metadata parsing. Allowed options
+        include "fastparquet", "pyarrow", and "auto". The specified
+        engine must be installed in the current environment. If
+        "auto" is specified, and both engines are installed,
+        "fastparquet" will take precedence over "pyarrow".
+    columns: list, optional
+        List of all column names that may be read from the file.
+    row_groups : list, optional
+        List of all row-groups that may be read from the file. This
+        may be a list of row-group indices (integers), or it may be
+        a list of `RowGroup` metadata objects (if the "fastparquet"
+        engine is used).
+    storage_options : dict, optional
+        Used to generate an `AbstractFileSystem` object if `fs` was
+        not specified.
+    max_gap : int, optional
+        Neighboring byte ranges will only be merged when their
+        inter-range gap is <= `max_gap`. Default is 64KB.
+    max_block : int, optional
+        Neighboring byte ranges will only be merged when the size of
+        the aggregated range is <= `max_block`. Default is 256MB.
+    footer_sample_size : int, optional
+        Number of bytes to read from the end of the path to look
+        for the footer metadata. If the sampled bytes do not contain
+        the footer, a second read request will be required, and
+        performance will suffer. Default is 1MB.
+    filters : list[list], optional
+        List of filters to apply to prevent reading row groups, of the
+        same format as accepted by the loading engines. Ignored if
+        ``row_groups`` is specified.
+    **kwargs :
+        Optional key-word arguments to pass to `fs.open`
+    """
+
+    # Make sure we have an `AbstractFileSystem` object
+    # to work with
+    if fs is None:
+        path0 = path
+        if isinstance(path, (list, tuple)):
+            path = path[0]
+        fs, path = url_to_fs(path, **(storage_options or {}))
+    else:
+        path0 = path
+
+    # For now, `columns == []` not supported, is the same
+    # as all columns
+    if columns is not None and len(columns) == 0:
+        columns = None
+
+    # Set the engine
+    engine = _set_engine(engine)
+
+    if isinstance(path0, (list, tuple)):
+        paths = path0
+    elif "*" in path:
+        paths = fs.glob(path)
+    elif path0.endswith("/"):  # or fs.isdir(path):
+        paths = [
+            _
+            for _ in fs.find(path, withdirs=False, detail=False)
+            if _.endswith((".parquet", ".parq"))
+        ]
+    else:
+        paths = [path]
+
+    data = _get_parquet_byte_ranges(
+        paths,
+        fs,
+        metadata=metadata,
+        columns=columns,
+        row_groups=row_groups,
+        engine=engine,
+        max_gap=max_gap,
+        max_block=max_block,
+        footer_sample_size=footer_sample_size,
+        filters=filters,
+    )
+
+    # Call self.open with "parts" caching
+    options = kwargs.pop("cache_options", {}).copy()
+    return [
+        AlreadyBufferedFile(
+            fs=None,
+            path=fn,
+            mode="rb",
+            cache_type="parts",
+            cache_options={
+                **options,
+                "data": ranges,
+            },
+            size=max(_[1] for _ in ranges),
+            **kwargs,
+        )
+        for fn, ranges in data.items()
+    ]
+
+
+def open_parquet_file(*args, **kwargs):
+    """Create files tailed to reading specific parts of parquet files
+
+    Please see ``open_parquet_files`` for details of the arguments. The
+    difference is, this function always returns a single ``AlreadyBufferedFile``,
+    whereas `open_parquet_files`` always returns a list of files, even if
+    there are one or zero matching parquet files.
+    """
+    return open_parquet_files(*args, **kwargs)[0]
+
+
+def _get_parquet_byte_ranges(
+    paths,
+    fs,
+    metadata=None,
+    columns=None,
+    row_groups=None,
+    max_gap=64_000,
+    max_block=256_000_000,
+    footer_sample_size=1_000_000,
+    engine="auto",
+    filters=None,
+):
+    """Get a dictionary of the known byte ranges needed
+    to read a specific column/row-group selection from a
+    Parquet dataset. Each value in the output dictionary
+    is intended for use as the `data` argument for the
+    `KnownPartsOfAFile` caching strategy of a single path.
+    """
+
+    # Set engine if necessary
+    if isinstance(engine, str):
+        engine = _set_engine(engine)
+
+    # Pass to a specialized function if metadata is defined
+    if metadata is not None:
+        # Use the provided parquet metadata object
+        # to avoid transferring/parsing footer metadata
+        return _get_parquet_byte_ranges_from_metadata(
+            metadata,
+            fs,
+            engine,
+            columns=columns,
+            row_groups=row_groups,
+            max_gap=max_gap,
+            max_block=max_block,
+            filters=filters,
+        )
+
+    # Populate global paths, starts, & ends
+    if columns is None and row_groups is None and filters is None:
+        # We are NOT selecting specific columns or row-groups.
+        #
+        # We can avoid sampling the footers, and just transfer
+        # all file data with cat_ranges
+        result = {path: {(0, len(data)): data} for path, data in fs.cat(paths).items()}
+    else:
+        # We ARE selecting specific columns or row-groups.
+        #
+        # Get file sizes asynchronously
+        file_sizes = fs.sizes(paths)
+        data_paths = []
+        data_starts = []
+        data_ends = []
+        # Gather file footers.
+        # We just take the last `footer_sample_size` bytes of each
+        # file (or the entire file if it is smaller than that)
+        footer_starts = [
+            max(0, file_size - footer_sample_size) for file_size in file_sizes
+        ]
+        footer_samples = fs.cat_ranges(paths, footer_starts, file_sizes)
+
+        # Check our footer samples and re-sample if necessary.
+        large_footer = []
+        for i, path in enumerate(paths):
+            footer_size = int.from_bytes(footer_samples[i][-8:-4], "little")
+            real_footer_start = file_sizes[i] - (footer_size + 8)
+            if real_footer_start < footer_starts[i]:
+                large_footer.append((i, real_footer_start))
+        if large_footer:
+            warnings.warn(
+                f"Not enough data was used to sample the parquet footer. "
+                f"Try setting footer_sample_size >= {large_footer}."
+            )
+            path0 = [paths[i] for i, _ in large_footer]
+            starts = [_[1] for _ in large_footer]
+            ends = [file_sizes[i] - footer_sample_size for i, _ in large_footer]
+            data = fs.cat_ranges(path0, starts, ends)
+            for i, (path, start, block) in enumerate(zip(path0, starts, data)):
+                footer_samples[i] = block + footer_samples[i]
+                footer_starts[i] = start
+        result = {
+            path: {(start, size): data}
+            for path, start, size, data in zip(
+                paths, footer_starts, file_sizes, footer_samples
+            )
+        }
+
+        # Calculate required byte ranges for each path
+        for i, path in enumerate(paths):
+            # Use "engine" to collect data byte ranges
+            path_data_starts, path_data_ends = engine._parquet_byte_ranges(
+                columns,
+                row_groups=row_groups,
+                footer=footer_samples[i],
+                footer_start=footer_starts[i],
+                filters=filters,
+            )
+
+            data_paths += [path] * len(path_data_starts)
+            data_starts += path_data_starts
+            data_ends += path_data_ends
+
+        # Merge adjacent offset ranges
+        data_paths, data_starts, data_ends = merge_offset_ranges(
+            data_paths,
+            data_starts,
+            data_ends,
+            max_gap=max_gap,
+            max_block=max_block,
+            sort=True,
+        )
+
+        # Transfer the data byte-ranges into local memory
+        _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+    # Add b"PAR1" to headers
+    _add_header_magic(result)
+
+    return result
+
+
+def _get_parquet_byte_ranges_from_metadata(
+    metadata,
+    fs,
+    engine,
+    columns=None,
+    row_groups=None,
+    max_gap=64_000,
+    max_block=256_000_000,
+    filters=None,
+):
+    """Simplified version of `_get_parquet_byte_ranges` for
+    the case that an engine-specific `metadata` object is
+    provided, and the remote footer metadata does not need to
+    be transferred before calculating the required byte ranges.
+    """
+
+    # Use "engine" to collect data byte ranges
+    data_paths, data_starts, data_ends = engine._parquet_byte_ranges(
+        columns, row_groups=row_groups, metadata=metadata, filters=filters
+    )
+
+    # Merge adjacent offset ranges
+    data_paths, data_starts, data_ends = merge_offset_ranges(
+        data_paths,
+        data_starts,
+        data_ends,
+        max_gap=max_gap,
+        max_block=max_block,
+        sort=False,  # Should be sorted
+    )
+
+    # Transfer the data byte-ranges into local memory
+    result = {fn: {} for fn in list(set(data_paths))}
+    _transfer_ranges(fs, result, data_paths, data_starts, data_ends)
+
+    # Add b"PAR1" to header
+    _add_header_magic(result)
+
+    return result
+
+
+def _transfer_ranges(fs, blocks, paths, starts, ends):
+    # Use cat_ranges to gather the data byte_ranges
+    ranges = (paths, starts, ends)
+    for path, start, stop, data in zip(*ranges, fs.cat_ranges(*ranges)):
+        blocks[path][(start, stop)] = data
+
+
+def _add_header_magic(data):
+    # Add b"PAR1" to file headers
+    for path in list(data):
+        add_magic = True
+        for k in data[path]:
+            if k[0] == 0 and k[1] >= 4:
+                add_magic = False
+                break
+        if add_magic:
+            data[path][(0, 4)] = b"PAR1"
+
+
+def _set_engine(engine_str):
+    # Define a list of parquet engines to try
+    if engine_str == "auto":
+        try_engines = ("fastparquet", "pyarrow")
+    elif not isinstance(engine_str, str):
+        raise ValueError(
+            "Failed to set parquet engine! "
+            "Please pass 'fastparquet', 'pyarrow', or 'auto'"
+        )
+    elif engine_str not in ("fastparquet", "pyarrow"):
+        raise ValueError(f"{engine_str} engine not supported by `fsspec.parquet`")
+    else:
+        try_engines = [engine_str]
+
+    # Try importing the engines in `try_engines`,
+    # and choose the first one that succeeds
+    for engine in try_engines:
+        try:
+            if engine == "fastparquet":
+                return FastparquetEngine()
+            elif engine == "pyarrow":
+                return PyarrowEngine()
+        except ImportError:
+            pass
+
+    # Raise an error if a supported parquet engine
+    # was not found
+    raise ImportError(
+        f"The following parquet engines are not installed "
+        f"in your python environment: {try_engines}."
+        f"Please install 'fastparquert' or 'pyarrow' to "
+        f"utilize the `fsspec.parquet` module."
+    )
+
+
+class FastparquetEngine:
+    # The purpose of the FastparquetEngine class is
+    # to check if fastparquet can be imported (on initialization)
+    # and to define a `_parquet_byte_ranges` method. In the
+    # future, this class may also be used to define other
+    # methods/logic that are specific to fastparquet.
+
+    def __init__(self):
+        import fastparquet as fp
+
+        self.fp = fp
+
+    def _parquet_byte_ranges(
+        self,
+        columns,
+        row_groups=None,
+        metadata=None,
+        footer=None,
+        footer_start=None,
+        filters=None,
+    ):
+        # Initialize offset ranges and define ParqetFile metadata
+        pf = metadata
+        data_paths, data_starts, data_ends = [], [], []
+        if filters and row_groups:
+            raise ValueError("filters and row_groups cannot be used together")
+        if pf is None:
+            pf = self.fp.ParquetFile(io.BytesIO(footer))
+
+        # Convert columns to a set and add any index columns
+        # specified in the pandas metadata (just in case)
+        column_set = None if columns is None else {c.split(".", 1)[0] for c in columns}
+        if column_set is not None and hasattr(pf, "pandas_metadata"):
+            md_index = [
+                ind
+                for ind in pf.pandas_metadata.get("index_columns", [])
+                # Ignore RangeIndex information
+                if not isinstance(ind, dict)
+            ]
+            column_set |= set(md_index)
+
+        # Check if row_groups is a list of integers
+        # or a list of row-group metadata
+        if filters:
+            from fastparquet.api import filter_row_groups
+
+            row_group_indices = None
+            row_groups = filter_row_groups(pf, filters)
+        elif row_groups and not isinstance(row_groups[0], int):
+            # Input row_groups contains row-group metadata
+            row_group_indices = None
+        else:
+            # Input row_groups contains row-group indices
+            row_group_indices = row_groups
+            row_groups = pf.row_groups
+        if column_set is not None:
+            column_set = [
+                _ if isinstance(_, list) else _.split(".") for _ in column_set
+            ]
+
+        # Loop through column chunks to add required byte ranges
+        for r, row_group in enumerate(row_groups):
+            # Skip this row-group if we are targeting
+            # specific row-groups
+            if row_group_indices is None or r in row_group_indices:
+                # Find the target parquet-file path for `row_group`
+                fn = pf.row_group_filename(row_group)
+
+                for column in row_group.columns:
+                    name = column.meta_data.path_in_schema
+                    # Skip this column if we are targeting specific columns
+                    if column_set is None or _cmp(name, column_set):
+                        file_offset0 = column.meta_data.dictionary_page_offset
+                        if file_offset0 is None:
+                            file_offset0 = column.meta_data.data_page_offset
+                        num_bytes = column.meta_data.total_compressed_size
+                        if footer_start is None or file_offset0 < footer_start:
+                            data_paths.append(fn)
+                            data_starts.append(file_offset0)
+                            data_ends.append(
+                                min(
+                                    file_offset0 + num_bytes,
+                                    footer_start or (file_offset0 + num_bytes),
+                                )
+                            )
+
+        if metadata:
+            # The metadata in this call may map to multiple
+            # file paths. Need to include `data_paths`
+            return data_paths, data_starts, data_ends
+        return data_starts, data_ends
+
+
+class PyarrowEngine:
+    # The purpose of the PyarrowEngine class is
+    # to check if pyarrow can be imported (on initialization)
+    # and to define a `_parquet_byte_ranges` method. In the
+    # future, this class may also be used to define other
+    # methods/logic that are specific to pyarrow.
+
+    def __init__(self):
+        import pyarrow.parquet as pq
+
+        self.pq = pq
+
+    def _parquet_byte_ranges(
+        self,
+        columns,
+        row_groups=None,
+        metadata=None,
+        footer=None,
+        footer_start=None,
+        filters=None,
+    ):
+        if metadata is not None:
+            raise ValueError("metadata input not supported for PyarrowEngine")
+        if filters:
+            # there must be a way!
+            raise NotImplementedError
+
+        data_starts, data_ends = [], []
+        md = self.pq.ParquetFile(io.BytesIO(footer)).metadata
+
+        # Convert columns to a set and add any index columns
+        # specified in the pandas metadata (just in case)
+        column_set = None if columns is None else set(columns)
+        if column_set is not None:
+            schema = md.schema.to_arrow_schema()
+            has_pandas_metadata = (
+                schema.metadata is not None and b"pandas" in schema.metadata
+            )
+            if has_pandas_metadata:
+                md_index = [
+                    ind
+                    for ind in json.loads(
+                        schema.metadata[b"pandas"].decode("utf8")
+                    ).get("index_columns", [])
+                    # Ignore RangeIndex information
+                    if not isinstance(ind, dict)
+                ]
+                column_set |= set(md_index)
+        if column_set is not None:
+            column_set = [
+                _[:1] if isinstance(_, list) else _.split(".")[:1] for _ in column_set
+            ]
+
+        # Loop through column chunks to add required byte ranges
+        for r in range(md.num_row_groups):
+            # Skip this row-group if we are targeting
+            # specific row-groups
+            if row_groups is None or r in row_groups:
+                row_group = md.row_group(r)
+                for c in range(row_group.num_columns):
+                    column = row_group.column(c)
+                    name = column.path_in_schema.split(".")
+                    # Skip this column if we are targeting specific columns
+                    if column_set is None or _cmp(name, column_set):
+                        meta = column.to_dict()
+                        # Any offset could be the first one
+                        file_offset0 = min(
+                            _
+                            for _ in [
+                                meta.get("dictionary_page_offset"),
+                                meta.get("data_page_offset"),
+                                meta.get("index_page_offset"),
+                            ]
+                            if _ is not None
+                        )
+                        if file_offset0 < footer_start:
+                            data_starts.append(file_offset0)
+                            data_ends.append(
+                                min(
+                                    meta["total_compressed_size"] + file_offset0,
+                                    footer_start,
+                                )
+                            )
+
+        data_starts.append(footer_start)
+        data_ends.append(footer_start + len(footer))
+        return data_starts, data_ends
+
+
+def _cmp(name, column_set):
+    return any(all(a == b for a, b in zip(name, _)) for _ in column_set)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/prefetcher.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/prefetcher.py
new file mode 100644
index 0000000000000000000000000000000000000000..b94b13b104a91f089da868e85d86828a45bb50a4
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/prefetcher.py
@@ -0,0 +1,873 @@
+import asyncio
+import logging
+import weakref
+from collections import deque
+
+from . import asyn as fsspec_asyn
+from .asyn import sync_teardown
+from .utils import _fast_slice
+
+logger = logging.getLogger(__name__)
+
+
+class RunningAverageTracker:
+    """Tracks a running average of values over a sliding window.
+
+    This is used to monitor read sizes and adaptively scale the
+    prefetching strategy based on recent user behavior.
+    """
+
+    def __init__(self, maxlen=10):
+        """Initializes the tracker with a specific window size.
+
+        Args:
+            maxlen (int): The maximum number of historical values to keep.
+        """
+        logger.debug("Initializing RunningAverageTracker with maxlen: %d", maxlen)
+        self._history = deque(maxlen=maxlen)
+        self._sum = 0
+
+    def add(self, value: int):
+        """Adds a new value to the sliding window and updates the rolling sum.
+
+        Args:
+            value (int): The integer value to add to the history.
+        """
+        if value <= 0:
+            raise ValueError(
+                "Internal error, RunningAverageTracker tried inserting negative value"
+            )
+        if len(self._history) == self._history.maxlen:
+            self._sum -= self._history[0]
+
+        self._history.append(value)
+        self._sum += value
+        logger.debug(
+            "RunningAverageTracker added value: %d, new sum: %d", value, self._sum
+        )
+
+    @property
+    def average(self) -> int:
+        """Calculates and returns the current running average.
+
+        Returns:
+            int: The integer average of the current history.
+        """
+        count = len(self._history)
+        if count == 0:
+            return 1024 * 1024  # 1MB
+        return self._sum // count
+
+    @property
+    def is_variable(self) -> bool:
+        """Determines if the history contains distinct chunk sizes."""
+        count = len(self._history)
+        if count < 2:
+            return False
+
+        return len(set(self._history)) > 1
+
+    @property
+    def last_value(self) -> int:
+        """Returns the most recent entry in the history."""
+        if not self._history:
+            raise RuntimeError("No entry found in history")
+
+        return self._history[-1]
+
+    def clear(self):
+        """Clears the history and resets the sum to zero."""
+        logger.debug("Clearing RunningAverageTracker history.")
+        self._history.clear()
+        self._sum = 0
+
+
+class PrefetchProducer:
+    """Background worker that fetches sequential blocks of data.
+
+    This class handles the network requests. It spawns asynchronous tasks
+    to fetch data ahead of the user's current reading position and
+    places those task promises into a queue for the consumer.
+    """
+
+    # If the request is too small, and prefetch window is expanded till 5MB
+    # we then make request in 5MB blocks.
+    MIN_CHUNK_SIZE = 5 * 1024 * 1024
+
+    # If user doesn't specify any max_prefetch_size, the prefetcher defaults
+    # to maximum of 2 * io_size and 128MB
+    MIN_PREFETCH_SIZE = 128 * 1024 * 1024
+
+    # The prefetching starts on the third read.
+    MIN_STREAKS_FOR_PREFETCHING = 3
+
+    # Threshold for disabling proactive prefetching on large, variable reads.
+    #
+    # If the average read size exceeds this value and patterns are variable,
+    # prefetching shifts from an I/O bottleneck to a memory(CPU) bottleneck. When a user
+    # requests random massive sizes (e.g., jumping between 64MB and INF), the
+    # producer still fetches chunks based on the rolling average. The consumer
+    # then has to pick up multiple chunks and stitch them together to match the
+    # exact requested size.
+    #
+    # For small average read sizes, this byte assembly is fast and the bottleneck
+    # remains the network I/O. However, for massive reads (>= 64MB), the extra
+    # step of copying and assembling huge byte strings in memory severely slows
+    # down the operation.
+    VARIABLE_IO_THRESHOLD = 64 * 1024 * 1024
+
+    def __init__(
+        self,
+        fetcher,
+        size: int,
+        concurrency: int,
+        queue: asyncio.Queue,
+        wakeup_event: asyncio.Event,
+        consumer: "PrefetchConsumer",
+        tracker: RunningAverageTracker,
+        orchestrator: "BackgroundPrefetcher",
+        user_max_prefetch_size=None,
+    ):
+        """Initializes the background producer.
+
+        Args:
+            fetcher (Callable): A coroutine function to fetch bytes from a remote source.
+            size (int): Total size of the file being fetched.
+            concurrency (int): Maximum number of concurrent fetch tasks.
+            queue (asyncio.Queue): The shared queue to push download tasks into.
+            wakeup_event (asyncio.Event): Event used to wake the producer from an idle state.
+            consumer (PrefetchConsumer): The consumer reading the prefetched chunks.
+            tracker (RunningAverageTracker): Tracker for history of read sizes.
+            orchestrator (BackgroundPrefetcher): The parent object managing the operation.
+            user_max_prefetch_size (int, optional): A hard limit for prefetch size overrides.
+        """
+        logger.debug(
+            "Initializing PrefetchProducer: size=%d, concurrency=%d, user_max_prefetch_size=%s",
+            size,
+            concurrency,
+            user_max_prefetch_size,
+        )
+        self.fetcher = fetcher
+        self.size = size
+        self.concurrency = concurrency
+        self.queue = queue
+        self.wakeup_event = wakeup_event
+
+        self.consumer = consumer
+        self.tracker = tracker
+        self.orchestrator = weakref.proxy(orchestrator)
+        self._user_max_prefetch_size = user_max_prefetch_size
+
+        self.current_offset = 0
+        self.is_stopped = False
+        self._active_tasks = set()
+        self._producer_task = None
+
+    @property
+    def max_prefetch_size(self) -> int:
+        """Calculates the maximum prefetch size based on user intent or io size.
+
+        Returns:
+            int: The maximum number of bytes to prefetch ahead.
+        """
+        if self._user_max_prefetch_size is not None:
+            return min(
+                self._user_max_prefetch_size,
+                max(2 * self.tracker.average, self.MIN_PREFETCH_SIZE),
+            )
+        return max(2 * self.tracker.average, self.MIN_PREFETCH_SIZE)
+
+    def start(self):
+        """Starts the background producer loop.
+
+        This clears any previous wakeup events and spawns the main loop task.
+        """
+        logger.debug("Starting PrefetchProducer loop.")
+        self.is_stopped = False
+        self.wakeup_event.clear()
+        self._producer_task = asyncio.create_task(self._loop())
+
+    async def stop(self):
+        """Cancels all active fetch tasks and shuts down the producer loop.
+
+        This method ensures the queue is flushed and waits for cancelled
+        tasks to finish cleaning up.
+        """
+        logger.debug(
+            "Stopping PrefetchProducer. Active fetch tasks: %d", len(self._active_tasks)
+        )
+        self.is_stopped = True
+        self.wakeup_event.set()
+
+        tasks_to_wait = []
+        if self._producer_task and not self._producer_task.done():
+            self._producer_task.cancel()
+            tasks_to_wait.append(self._producer_task)
+
+        tasks_to_wait.extend(
+            task for task in list(self._active_tasks) if not task.done()
+        )
+
+        # We do not cancel the network task, instead we wait on them.
+        # This is intentionally done to avoid MRD stream disruption.
+        self._active_tasks.clear()
+
+        # Clear out any leftover items in the queue
+        cleared_items = 0
+        while not self.queue.empty():
+            try:
+                item = self.queue.get_nowait()
+                if (
+                    isinstance(item, asyncio.Task)
+                    and item.done()
+                    and not item.cancelled()
+                ):
+                    item.exception()
+                cleared_items += 1
+            except asyncio.QueueEmpty:
+                break
+
+        if cleared_items > 0:
+            logger.debug(
+                "Cleared %d leftover items from the queue during stop.", cleared_items
+            )
+
+        if tasks_to_wait:
+            logger.debug(
+                "Waiting for %d cancelled tasks to finish their teardown.",
+                len(tasks_to_wait),
+            )
+            await asyncio.gather(*tasks_to_wait, return_exceptions=True)
+
+        self.wakeup_event.clear()
+
+    async def restart(self, new_offset: int):
+        """Stops current tasks and restarts the background loop at a new byte offset.
+
+        Args:
+            new_offset (int): The new byte position to start prefetching from.
+        """
+        logger.debug("Restarting PrefetchProducer at new offset: %d", new_offset)
+        await self.stop()
+        self.current_offset = new_offset
+        self.start()
+
+    async def _loop(self):
+        """The main background loop that delegates calculations and spawns tasks."""
+        logger.debug("PrefetchProducer internal loop is now running.")
+        try:
+            while not self.is_stopped:
+                await self.wakeup_event.wait()
+                self.wakeup_event.clear()
+
+                if self.is_stopped:
+                    break
+
+                await self._process_prefetch_cycle()
+
+        except asyncio.CancelledError:
+            logger.debug("PrefetchProducer loop was cancelled.")
+        except Exception as e:
+            logger.exception("PrefetchProducer loop encountered an unexpected error.")
+            self.is_stopped = True
+            self.orchestrator.set_error(e)
+            await self.queue.put(e)
+
+    def _calculate_prefetch_params(self) -> tuple[int, int, int]:
+        """
+        Evaluates current trackers and state to determine sizes.
+
+        Returns:
+            tuple: (prefetch_size, io_size, effective_prefetch_size)
+        """
+        avg_io_size = self.tracker.average
+        streak = self.consumer.sequential_streak
+        is_variable = self.tracker.is_variable
+        last_read_size = self.tracker.last_value
+
+        exceeds_user_max = (
+            self._user_max_prefetch_size is not None
+            and avg_io_size > self._user_max_prefetch_size
+        )
+
+        # Disable prefetching ahead if variable AND average > 64MB, or if it exceeds user max
+        if (
+            is_variable and avg_io_size > self.VARIABLE_IO_THRESHOLD
+        ) or exceeds_user_max:
+            logger.debug(
+                "Large IO detected (variable > 64MB or > user max). Disabling background prefetching."
+            )
+            prefetch_multiplier = 1
+        elif streak < self.MIN_STREAKS_FOR_PREFETCHING:
+            prefetch_multiplier = 1
+        else:
+            prefetch_multiplier = streak - self.MIN_STREAKS_FOR_PREFETCHING + 1
+
+        if self.queue.empty() or prefetch_multiplier == 1:
+            io_size = last_read_size
+        else:
+            io_size = avg_io_size
+
+        prefetch_size = min(prefetch_multiplier * io_size, self.max_prefetch_size)
+        if self.consumer.offset + prefetch_size < self.consumer.target_offset:
+            prefetch_size = self.consumer.target_offset - self.consumer.offset
+
+        if is_variable:
+            effective_prefetch_size = prefetch_size
+        else:
+            effective_prefetch_size = (prefetch_size // io_size) * io_size
+            if effective_prefetch_size == 0:
+                effective_prefetch_size = prefetch_size
+
+        return prefetch_size, io_size, effective_prefetch_size
+
+    async def _process_prefetch_cycle(self):
+        """Executes a single cycle of enqueuing fetch tasks."""
+        prefetch_size, io_size, effective_prefetch_size = (
+            self._calculate_prefetch_params()
+        )
+
+        logger.debug(
+            "Producer awake. Current offset: %d, User offset: %d, Prefetch size: %d",
+            self.current_offset,
+            self.consumer.offset,
+            prefetch_size,
+        )
+
+        while (
+            not self.is_stopped
+            and (self.current_offset - self.consumer.offset) < prefetch_size
+            and self.current_offset < self.size
+        ):
+            user_offset = self.consumer.offset
+            space_remaining = self.size - self.current_offset
+            prefetch_space_available = prefetch_size - (
+                self.current_offset - user_offset
+            )
+
+            if prefetch_size >= self.MIN_CHUNK_SIZE:
+                if prefetch_space_available >= self.MIN_CHUNK_SIZE:
+                    actual_size = min(
+                        max(self.MIN_CHUNK_SIZE, io_size), space_remaining
+                    )
+                else:
+                    break
+            else:
+                actual_size = min(io_size, space_remaining)
+
+            if prefetch_space_available < actual_size:
+                if (
+                    self.tracker.is_variable
+                    or prefetch_space_available == prefetch_size
+                ):
+                    actual_size = prefetch_space_available
+                else:
+                    break
+
+            streak = self.consumer.sequential_streak
+            if streak < self.MIN_STREAKS_FOR_PREFETCHING:
+                sfactor = self.concurrency
+            else:
+                sfactor = min(
+                    self.concurrency,
+                    max(
+                        1,
+                        actual_size * self.concurrency // effective_prefetch_size,
+                    ),
+                )
+
+            logger.debug(
+                "Spawning fetch task. Offset: %d, Size: %d, Split Factor: %d",
+                self.current_offset,
+                actual_size,
+                sfactor,
+            )
+
+            download_task = asyncio.create_task(
+                self.fetcher(self.current_offset, actual_size, split_factor=sfactor)
+            )
+            self._active_tasks.add(download_task)
+            download_task.add_done_callback(self._active_tasks.discard)
+
+            await self.queue.put(download_task)
+            self.current_offset += actual_size
+
+        if self.current_offset >= self.size:
+            logger.debug("Producer reached EOF. Exiting background loop.")
+            self.is_stopped = True
+
+
+class PrefetchConsumer:
+    """Consumes prefetched chunks from the queue and manages byte slicing.
+
+    This class pulls data out of the shared queue and slices it into the
+    exact byte sizes requested by the user. It also manages the local block buffer.
+    """
+
+    def __init__(
+        self,
+        queue: asyncio.Queue,
+        wakeup_event: asyncio.Event,
+        tracker: RunningAverageTracker,
+        orchestrator: "BackgroundPrefetcher",
+    ):
+        """Initializes the consumer.
+
+        Args:
+            queue (asyncio.Queue): The shared queue containing fetch tasks.
+            wakeup_event (asyncio.Event): Event used to wake the producer when more data is needed.
+            tracker (RunningAverageTracker): Tracker for history of read sizes.
+            orchestrator (BackgroundPrefetcher): The parent object managing the operation.
+        """
+        logger.debug("Initializing PrefetchConsumer.")
+        self.queue = queue
+        self.wakeup_event = wakeup_event
+        self.tracker = tracker
+        self.orchestrator = weakref.proxy(orchestrator)
+        self.sequential_streak = 0
+        self.offset = 0
+        self.target_offset = 0
+        self._current_block = b""
+        self._current_block_idx = 0
+
+    def seek(self, new_offset: int):
+        """Clears the buffer and resets the internal offset for a hard seek.
+
+        Args:
+            new_offset (int): The byte position the consumer is jumping to.
+        """
+        logger.debug(
+            "Consumer executing hard seek to offset %d. Clearing internal buffer.",
+            new_offset,
+        )
+        self.offset = new_offset
+        self.target_offset = new_offset
+        self.sequential_streak = 0
+        self._current_block = b""
+        self._current_block_idx = 0
+
+    def clear_buffer(self):
+        """Discards the local byte buffer. Useful during shutdown or resets."""
+        logger.debug("Consumer local block buffer cleared.")
+        self._current_block = b""
+        self._current_block_idx = 0
+
+    async def _advance(self, size: int, save_data: bool) -> list[bytes]:
+        """Internal method to advance the offset and optionally extract data.
+
+        Handles queue exhaustion, producer wakeups, and streak tracking.
+        """
+        if size <= 0:
+            return []
+
+        chunks = []
+        processed = 0
+        self.target_offset = self.offset + size
+
+        while processed < size:
+            available = len(self._current_block) - self._current_block_idx
+            trigger_wakeup = False
+
+            if not available:
+                is_producer_stopped = (
+                    self.orchestrator.producer is None
+                    or self.orchestrator.producer.is_stopped
+                )
+                if is_producer_stopped and self.queue.empty():
+                    logger.debug("Consumer reached EOF.")
+                    break
+
+                if self.queue.empty():
+                    logger.debug("Queue is empty. Waking up producer.")
+                    self.wakeup_event.set()
+
+                task = await self.queue.get()
+
+                if isinstance(task, Exception):
+                    logger.error("Consumer retrieved an exception: %s", task)
+                    self.orchestrator.set_error(task)
+                    raise task
+
+                try:
+                    block = await task
+
+                    self.sequential_streak += 1
+                    if (
+                        self.sequential_streak
+                        >= PrefetchProducer.MIN_STREAKS_FOR_PREFETCHING
+                    ):
+                        exceeds_user_max = (
+                            self.orchestrator.max_prefetch_size is not None
+                            and self.tracker.average
+                            > self.orchestrator.max_prefetch_size
+                        )
+                        is_massive_variable = (
+                            self.tracker.is_variable
+                            and self.tracker.average
+                            > PrefetchProducer.VARIABLE_IO_THRESHOLD
+                        )
+
+                        # Suppress proactive wakeups to prevent large CPU assembly
+                        # on erratic large reads or exceeding max
+                        if not (is_massive_variable or exceeds_user_max):
+                            trigger_wakeup = True
+                        else:
+                            logger.debug(
+                                "Suppressing proactive producer wakeup due to massive variable"
+                                " workload or exceeding user max prefetch."
+                            )
+
+                    self._current_block = block
+                    self._current_block_idx = 0
+                    available = len(self._current_block)
+                except asyncio.CancelledError:
+                    raise
+                except Exception as e:
+                    logger.exception("Consumer caught an error.")
+                    self.orchestrator.set_error(e)
+                    raise e
+
+            if not self._current_block:
+                break
+
+            needed = size - processed
+            take = min(needed, available)
+
+            if save_data:
+                if take == len(self._current_block) and self._current_block_idx == 0:
+                    chunk = self._current_block
+                else:
+                    # Native Python slicing was GIL bound in my experiments.
+                    chunk = await asyncio.to_thread(
+                        _fast_slice, self._current_block, self._current_block_idx, take
+                    )
+                chunks.append(chunk)
+
+            self._current_block_idx += take
+            processed += take
+            self.offset += take
+            if trigger_wakeup:
+                self.wakeup_event.set()
+
+        return chunks
+
+    async def consume(self, size: int) -> bytes:
+        """Pulls exactly 'size' bytes from the local block or the task queue.
+
+        If the local block is exhausted, this will wait on the queue for the next
+        available chunk of data.
+
+        Args:
+            size (int): The exact number of bytes to retrieve.
+
+        Returns:
+            bytes: The requested bytes. This may be shorter than 'size' if EOF is reached.
+
+        Raises:
+            Exception: Re-raises any exceptions encountered by the producer fetch tasks.
+        """
+        if size <= 0:
+            return b""
+
+        chunks = await self._advance(size, save_data=True)
+
+        if not chunks:
+            return b""
+
+        if len(chunks) == 1:
+            return chunks[0]
+
+        return await asyncio.to_thread(b"".join, chunks)
+
+    async def skip(self, size: int) -> None:
+        """Advances the consumer offset without allocating memory."""
+        await self._advance(size, save_data=False)
+
+
+class BackgroundPrefetcher:
+    """Orchestrator that manages reading behavior and coordinates background work.
+
+    This acts as the main public interface for the file reader. It tracks the
+    user's reading history, routes seek operations, and links the producer's
+    network tasks with the consumer's data slicing logic.
+    """
+
+    producer = None
+
+    def __init__(
+        self, fetcher, size: int, concurrency: int, max_prefetch_size=None, loop=None
+    ):
+        """Initializes the background prefetcher.
+
+        Args:
+            fetcher (Callable): A coroutine of the form `f(start, end)` which gets bytes from the remote.
+            size (int): Total byte size of the file being read.
+            concurrency (int): Number of concurrent network requests to use for large chunks.
+            max_prefetch_size (int, optional): Maximum bytes to prefetch ahead of the current user offset.
+            loop (asyncio.AbstractEventLoop, optional): The event loop to attach the prefetcher to.
+                If executing synchronously, this should be the fsspec background loop. If executing
+                asynchronously (asynchronous=True), this should be None so it can automatically
+                inherit the user's currently running event loop.
+
+        Raises:
+            ValueError: If max_prefetch_size is provided but is not a positive integer.
+        """
+        logger.debug(
+            "Starting BackgroundPrefetcher. Size: %d, Concurrency: %d, Max Prefetch: %s",
+            size,
+            concurrency,
+            max_prefetch_size,
+        )
+        self.size = size
+        self.concurrency = concurrency
+        self.max_prefetch_size = max_prefetch_size
+
+        if max_prefetch_size is not None and max_prefetch_size <= 0:
+            logger.error("Invalid max_prefetch_size provided: %s", max_prefetch_size)
+            raise ValueError(
+                "max_prefetch_size should be a positive integer to use adaptive prefetching!"
+            )
+
+        self.loop = loop
+        self._error = None
+        self.is_stopped = False
+        self.user_offset = 0
+        self.read_tracker = RunningAverageTracker(maxlen=10)
+
+        self.queue = None
+        self.wakeup_event = None
+        self._async_lock = None
+        self.consumer = None
+        self.producer = None
+
+        def _start():
+            # Ensures all primitives bind directly to `self.loop`
+            self.queue = asyncio.Queue()
+            self.wakeup_event = asyncio.Event()
+            self._async_lock = asyncio.Lock()
+
+            self.consumer = PrefetchConsumer(
+                queue=self.queue,
+                wakeup_event=self.wakeup_event,
+                tracker=self.read_tracker,
+                orchestrator=self,
+            )
+
+            self.producer = PrefetchProducer(
+                fetcher=fetcher,
+                size=self.size,
+                concurrency=self.concurrency,
+                queue=self.queue,
+                wakeup_event=self.wakeup_event,
+                consumer=self.consumer,
+                tracker=self.read_tracker,
+                orchestrator=self,
+                user_max_prefetch_size=max_prefetch_size,
+            )
+            self.producer.start()
+
+        try:
+            current_loop = asyncio.get_running_loop()
+        except RuntimeError:
+            current_loop = None
+
+        if current_loop is self.loop and self.loop is not None:
+            # We are already safely running inside the fsspec background loop
+            _start()
+        elif self.loop is not None:
+            # We are on the main thread; schedule setup on the fsspec background loop
+            async def _start_wrapper():
+                _start()
+
+            fsspec_asyn.sync(self.loop, _start_wrapper)
+        elif current_loop is not None:
+            # asynchronous=True: use the user's active event loop
+            self.loop = current_loop
+            _start()
+        else:
+            # asynchronous=True but called completely outside of an async context
+            raise RuntimeError("No event loop found")
+
+        logger.debug("BackgroundPrefetcher initialization complete.")
+
+    def __enter__(self):
+        """Context manager entry point."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit point. Ensures the prefetcher is cleanly closed."""
+        self.close()
+
+    async def __aenter__(self):
+        """Async context manager entry point."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit point. Ensures the prefetcher is cleanly closed."""
+        await self.aclose()
+
+    def set_error(self, e: Exception):
+        logger.error("Global error state set in BackgroundPrefetcher: %s", e)
+        self._error = e
+
+    async def _restart_producer(self, new_offset: int):
+        logger.debug(
+            "Handling seek request. Restarting producer at offset: %d", new_offset
+        )
+        self._error = None
+        await self.producer.restart(new_offset)
+        self.consumer.seek(new_offset)
+        self.read_tracker.clear()
+
+    async def _async_fetch(self, start, end):
+        """Core internal async fetching logic, protected safely by the async lock."""
+        async with self._async_lock:
+            try:
+                if self.is_stopped:
+                    raise RuntimeError("The file instance has been closed.")
+
+                logger.debug("Executing _async_fetch for range %d - %d.", start, end)
+
+                # If the prefetcher is in error state, let's do a hard seek to start offset.
+                if self._error:
+                    logger.info(
+                        "Recovering from error state. Restarting producer at offset: %d",
+                        start,
+                    )
+                    self.user_offset = start
+                    await self._restart_producer(start)
+                elif start != self.user_offset:
+                    block_offset = (
+                        self.consumer.offset - self.consumer._current_block_idx
+                    )
+                    if self.user_offset < start <= self.producer.current_offset:
+                        logger.debug(
+                            "Soft seek detected. Skipping ahead from %d to %d.",
+                            self.user_offset,
+                            start,
+                        )
+                        skip_amount = start - self.user_offset
+                        await self.consumer.skip(skip_amount)
+                        self.user_offset = start
+                    elif block_offset <= start < self.consumer.offset:
+                        logger.debug(
+                            "Local seek performed. User offset moved from %d to %d. "
+                            "Adjusting buffer index from %d to %d.",
+                            self.user_offset,
+                            start,
+                            self.consumer._current_block_idx,
+                            start - block_offset,
+                        )
+                        self.consumer._current_block_idx = start - block_offset
+                        self.consumer.offset = start
+                        self.consumer.target_offset = start
+                        self.user_offset = start
+                    else:
+                        logger.debug(
+                            "Hard seek detected. Moving user offset from %d to %d.",
+                            self.user_offset,
+                            start,
+                        )
+                        self.user_offset = start
+                        await self._restart_producer(start)
+
+                requested_size = end - start
+                self.read_tracker.add(requested_size)
+
+                chunk = await self.consumer.consume(requested_size)
+                self.user_offset += len(chunk)
+
+                logger.debug("Completed _async_fetch. Returned %d bytes.", len(chunk))
+                return chunk
+            except asyncio.CancelledError as e:
+                self._error = e
+                raise
+            except Exception as e:
+                logger.exception("Exception raised during asynchronous fetch.")
+                self._error = e
+                if self.producer and not self.producer.is_stopped:
+                    await self.producer.stop()
+                raise
+
+    async def _async_close(self):
+        """Asynchronous teardown logic protected by the async lock.
+
+        Held for the duration of teardown so a concurrent in-flight
+        ``_async_fetch`` cannot observe a stopped producer/empty queue as
+        EOF and silently return a truncated read.
+        """
+        async with self._async_lock:
+            logger.debug("Signaling prefetcher stop and tearing down producer.")
+
+            if self.producer and not self.producer.is_stopped:
+                await self.producer.stop()
+
+            self.consumer.clear_buffer()
+            logger.debug("BackgroundPrefetcher closed successfully.")
+
+    async def afetch(self, start: int | None, end: int | None) -> bytes:
+        """Asynchronous API counterpart to `_fetch`."""
+        if start is None:
+            start = 0
+        if end is None:
+            end = self.size
+
+        end = min(end, self.size)
+        logger.debug(
+            "Asynchronous afetch called for bounds start=%s, end=%s.", start, end
+        )
+
+        if start >= self.size or start >= end:
+            return b""
+
+        if self.is_stopped:
+            logger.error(
+                "Cannot fetch data: BackgroundPrefetcher is stopped or closed."
+            )
+            raise RuntimeError(
+                "The file instance has been closed. This can occur if a close operation "
+                "is executed concurrently while a read operation is still in progress."
+            )
+
+        return await self._async_fetch(start, end)
+
+    def fetch(self, start: int | None, end: int | None) -> bytes:
+        """Synchronous API wrapper delegating to `afetch`."""
+        # Delegates all boundaries, checking, and fetching to the async event loop perfectly
+        return fsspec_asyn.sync(self.loop, self.afetch, start, end)
+
+    async def aclose(self):
+        """Safely shuts down the prefetcher from an asynchronous context."""
+        self.is_stopped = True
+        await self._async_close()
+
+    def close(self, timeout: float | None = 10.0):
+        """Safely shuts down the prefetcher from a synchronous context.
+
+        Schedules teardown on the IO loop. If the wait times out, teardown
+        continues in the background to let in-flight reads finish cleanly.
+
+        Args:
+            timeout: Maximum seconds to wait for teardown to finish. Defaults
+                to 10.0 seconds. If 0 or negative, teardown runs fire-and-forget.
+                If None, waits indefinitely.
+        """
+        self.is_stopped = True
+
+        try:
+            sync_teardown(
+                self.loop,
+                self._async_close,
+                timeout=timeout,
+                description="BackgroundPrefetcher teardown",
+            )
+        except fsspec_asyn.FSTimeoutError:
+            logger.warning(
+                "BackgroundPrefetcher teardown did not complete within %ss; "
+                "it will keep running in the background.",
+                timeout,
+            )
+        except Exception:
+            logger.warning(
+                "Exception while closing BackgroundPrefetcher", exc_info=True
+            )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/registry.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/registry.py
new file mode 100644
index 0000000000000000000000000000000000000000..305d1e8908504fb6c38e94708bd7f20dba722705
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/registry.py
@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+import importlib
+import types
+import warnings
+
+__all__ = ["registry", "get_filesystem_class", "default"]
+
+# internal, mutable
+_registry: dict[str, type] = {}
+
+# external, immutable
+registry = types.MappingProxyType(_registry)
+default = "file"
+
+
+def register_implementation(name, cls, clobber=False, errtxt=None):
+    """Add implementation class to the registry
+
+    Parameters
+    ----------
+    name: str
+        Protocol name to associate with the class
+    cls: class or str
+        if a class: fsspec-compliant implementation class (normally inherits from
+        ``fsspec.AbstractFileSystem``, gets added straight to the registry. If a
+        str, the full path to an implementation class like package.module.class,
+        which gets added to known_implementations,
+        so the import is deferred until the filesystem is actually used.
+    clobber: bool (optional)
+        Whether to overwrite a protocol with the same name; if False, will raise
+        instead.
+    errtxt: str (optional)
+        If given, then a failure to import the given class will result in this
+        text being given.
+    """
+    if isinstance(cls, str):
+        if name in known_implementations and clobber is False:
+            if cls != known_implementations[name]["class"]:
+                raise ValueError(
+                    f"Name ({name}) already in the known_implementations and clobber "
+                    f"is False"
+                )
+        else:
+            known_implementations[name] = {
+                "class": cls,
+                "err": errtxt or f"{cls} import failed for protocol {name}",
+            }
+
+    else:
+        if name in registry and clobber is False:
+            if _registry[name] is not cls:
+                raise ValueError(
+                    f"Name ({name}) already in the registry and clobber is False"
+                )
+        else:
+            _registry[name] = cls
+
+
+# protocols mapped to the class which implements them. This dict can be
+# updated with register_implementation
+known_implementations = {
+    "abfs": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "adl": {
+        "class": "adlfs.AzureDatalakeFileSystem",
+        "err": (
+            "Azure Data Lake Storage Gen1 is retired and no longer supported. Please "
+            "install adlfs and use the `az://` protocol to access Azure Blob Storage "
+            "and Azure Data Lake Storage Gen2 instead."
+        ),
+    },
+    "arrow_hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "async_wrapper": {
+        "class": "fsspec.implementations.asyn_wrapper.AsyncFileSystemWrapper",
+    },
+    "asynclocal": {
+        "class": "morefs.asyn_local.AsyncLocalFileSystem",
+        "err": "Install 'morefs[asynclocalfs]' to use AsyncLocalFileSystem",
+    },
+    "asyncwrapper": {
+        "class": "fsspec.implementations.asyn_wrapper.AsyncFileSystemWrapper",
+    },
+    "az": {
+        "class": "adlfs.AzureBlobFileSystem",
+        "err": "Install adlfs to access Azure Datalake Gen2 and Azure Blob Storage",
+    },
+    "blockcache": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "box": {
+        "class": "boxfs.BoxFileSystem",
+        "err": "Please install boxfs to access BoxFileSystem",
+    },
+    "cached": {"class": "fsspec.implementations.cached.CachingFileSystem"},
+    "dask": {
+        "class": "fsspec.implementations.dask.DaskWorkerFileSystem",
+        "err": "Install dask distributed to access worker file system",
+    },
+    "data": {"class": "fsspec.implementations.data.DataFileSystem"},
+    "dbfs": {
+        "class": "fsspec.implementations.dbfs.DatabricksFileSystem",
+        "err": "Install the requests package to use the DatabricksFileSystem",
+    },
+    "dir": {"class": "fsspec.implementations.dirfs.DirFileSystem"},
+    "dropbox": {
+        "class": "dropboxdrivefs.DropboxDriveFileSystem",
+        "err": (
+            'DropboxFileSystem requires "dropboxdrivefs","requests" and "'
+            '"dropbox" to be installed'
+        ),
+    },
+    "dvc": {
+        "class": "dvc.api.DVCFileSystem",
+        "err": "Install dvc to access DVCFileSystem",
+    },
+    "file": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "filecache": {"class": "fsspec.implementations.cached.WholeFileCacheFileSystem"},
+    "ftp": {"class": "fsspec.implementations.ftp.FTPFileSystem"},
+    "gcs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "gdrive": {
+        "class": "gdrive_fsspec.GoogleDriveFileSystem",
+        "err": "Please install gdrive_fs for access to Google Drive",
+    },
+    "generic": {"class": "fsspec.generic.GenericFileSystem"},
+    "gist": {
+        "class": "fsspec.implementations.gist.GistFileSystem",
+        "err": "Install the requests package to use the gist FS",
+    },
+    "git": {
+        "class": "fsspec.implementations.git.GitFileSystem",
+        "err": "Install pygit2 to browse local git repos",
+    },
+    "github": {
+        "class": "fsspec.implementations.github.GithubFileSystem",
+        "err": "Install the requests package to use the github FS",
+    },
+    "gs": {
+        "class": "gcsfs.GCSFileSystem",
+        "err": "Please install gcsfs to access Google Storage",
+    },
+    "hdfs": {
+        "class": "fsspec.implementations.arrow.HadoopFileSystem",
+        "err": "pyarrow and local java libraries required for HDFS",
+    },
+    "hf": {
+        "class": "huggingface_hub.HfFileSystem",
+        "err": "Install huggingface_hub to access HfFileSystem",
+    },
+    "http": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "https": {
+        "class": "fsspec.implementations.http.HTTPFileSystem",
+        "err": 'HTTPFileSystem requires "requests" and "aiohttp" to be installed',
+    },
+    "jlab": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "jupyter": {
+        "class": "fsspec.implementations.jupyter.JupyterFileSystem",
+        "err": "Jupyter FS requires requests to be installed",
+    },
+    "lakefs": {
+        "class": "lakefs_spec.LakeFSFileSystem",
+        "err": "Please install lakefs-spec to access LakeFSFileSystem",
+    },
+    "libarchive": {
+        "class": "fsspec.implementations.libarchive.LibArchiveFileSystem",
+        "err": "LibArchive requires to be installed",
+    },
+    "local": {"class": "fsspec.implementations.local.LocalFileSystem"},
+    "memory": {"class": "fsspec.implementations.memory.MemoryFileSystem"},
+    "oci": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Object Storage",
+    },
+    "ocilake": {
+        "class": "ocifs.OCIFileSystem",
+        "err": "Install ocifs to access OCI Data Lake",
+    },
+    "oss": {
+        "class": "ossfs.OSSFileSystem",
+        "err": "Install ossfs to access Alibaba Object Storage System",
+    },
+    "pyscript": {
+        "class": "pyscript_fsspec_client.client.PyscriptFileSystem",
+        "err": "This only runs in a pyscript context",
+    },
+    "reference": {"class": "fsspec.implementations.reference.ReferenceFileSystem"},
+    "root": {
+        "class": "fsspec_xrootd.XRootDFileSystem",
+        "err": (
+            "Install fsspec-xrootd to access xrootd storage system. "
+            "Note: 'root' is the protocol name for xrootd storage systems, "
+            "not referring to root directories"
+        ),
+    },
+    "s3": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "s3a": {"class": "s3fs.S3FileSystem", "err": "Install s3fs to access S3"},
+    "sftp": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "simplecache": {"class": "fsspec.implementations.cached.SimpleCacheFileSystem"},
+    "smb": {
+        "class": "fsspec.implementations.smb.SMBFileSystem",
+        "err": 'SMB requires "smbprotocol" or "smbprotocol[kerberos]" installed',
+    },
+    "ssh": {
+        "class": "fsspec.implementations.sftp.SFTPFileSystem",
+        "err": 'SFTPFileSystem requires "paramiko" to be installed',
+    },
+    "tar": {"class": "fsspec.implementations.tar.TarFileSystem"},
+    "tos": {
+        "class": "tosfs.TosFileSystem",
+        "err": "Install tosfs to access ByteDance volcano engine Tinder Object Storage",
+    },
+    "tosfs": {
+        "class": "tosfs.TosFileSystem",
+        "err": "Install tosfs to access ByteDance volcano engine Tinder Object Storage",
+    },
+    "wandb": {"class": "wandbfs.WandbFS", "err": "Install wandbfs to access wandb"},
+    "webdav": {
+        "class": "webdav4.fsspec.WebdavFileSystem",
+        "err": "Install webdav4 to access WebDAV",
+    },
+    "webhdfs": {
+        "class": "fsspec.implementations.webhdfs.WebHDFS",
+        "err": 'webHDFS access requires "requests" to be installed',
+    },
+    "zip": {"class": "fsspec.implementations.zip.ZipFileSystem"},
+}
+
+assert list(known_implementations) == sorted(known_implementations), (
+    "Not in alphabetical order"
+)
+
+
+def get_filesystem_class(protocol):
+    """Fetch named protocol implementation from the registry
+
+    The dict ``known_implementations`` maps protocol names to the locations
+    of classes implementing the corresponding file-system. When used for the
+    first time, appropriate imports will happen and the class will be placed in
+    the registry. All subsequent calls will fetch directly from the registry.
+
+    Some protocol implementations require additional dependencies, and so the
+    import may fail. In this case, the string in the "err" field of the
+    ``known_implementations`` will be given as the error message.
+    """
+    if not protocol:
+        protocol = default
+
+    if protocol not in registry:
+        if protocol not in known_implementations:
+            raise ValueError(f"Protocol not known: {protocol}")
+        bit = known_implementations[protocol]
+        try:
+            register_implementation(protocol, _import_class(bit["class"]))
+        except ImportError as e:
+            raise ImportError(bit.get("err")) from e
+    cls = registry[protocol]
+    if getattr(cls, "protocol", None) in ("abstract", None):
+        cls.protocol = protocol
+
+    return cls
+
+
+s3_msg = """Your installed version of s3fs is very old and known to cause
+severe performance issues, see also https://github.com/dask/dask/issues/10276
+
+To fix, you should specify a lower version bound on s3fs, or
+update the current installation.
+"""
+
+
+def _import_class(fqp: str):
+    """Take a fully-qualified path and return the imported class or identifier.
+
+    ``fqp`` is of the form "package.module.klass" or
+    "package.module:subobject.klass".
+
+    Warnings
+    --------
+    This can import arbitrary modules. Make sure you haven't installed any modules
+    that may execute malicious code at import time.
+    """
+    if ":" in fqp:
+        mod, name = fqp.rsplit(":", 1)
+    else:
+        mod, name = fqp.rsplit(".", 1)
+
+    is_s3 = mod == "s3fs"
+    mod = importlib.import_module(mod)
+    if is_s3 and mod.__version__.split(".") < ["0", "5"]:
+        warnings.warn(s3_msg)
+    for part in name.split("."):
+        mod = getattr(mod, part)
+
+    if not isinstance(mod, type):
+        raise TypeError(f"{fqp} is not a class")
+
+    return mod
+
+
+def filesystem(protocol, **storage_options):
+    """Instantiate filesystems for given protocol and arguments
+
+    ``storage_options`` are specific to the protocol being chosen, and are
+    passed directly to the class.
+    """
+    if protocol == "arrow_hdfs":
+        warnings.warn(
+            "The 'arrow_hdfs' protocol has been deprecated and will be "
+            "removed in the future. Specify it as 'hdfs'.",
+            DeprecationWarning,
+        )
+
+    cls = get_filesystem_class(protocol)
+    return cls(**storage_options)
+
+
+def available_protocols():
+    """Return a list of the implemented protocols.
+
+    Note that any given protocol may require extra packages to be importable.
+    """
+    return list(known_implementations)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/spec.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/spec.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ec41353861f661f8d1dd8ee48df0ac9c252fe2f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/spec.py
@@ -0,0 +1,2353 @@
+from __future__ import annotations
+
+import io
+import json
+import logging
+import os
+import threading
+import warnings
+import weakref
+from errno import ESPIPE
+from glob import has_magic
+from hashlib import sha256
+from typing import Any
+
+from .callbacks import DEFAULT_CALLBACK
+from .config import apply_config, conf
+from .dircache import DirCache
+from .transaction import Transaction
+from .utils import (
+    _unstrip_protocol,
+    check_contained,
+    glob_translate,
+    isfilelike,
+    other_paths,
+    read_block,
+    stringify_path,
+    tokenize,
+)
+
+logger = logging.getLogger("fsspec")
+
+
+def make_instance(cls, args, kwargs):
+    return cls(*args, **kwargs)
+
+
+FORK_AVAILABLE = hasattr(os, "register_at_fork")
+
+
+if FORK_AVAILABLE:
+    _registered_classes = weakref.WeakSet()
+
+    def _reset_instances_lock():
+        for cls in _registered_classes:
+            cls._instantiation_lock = threading.RLock()
+            cls._cache.clear()
+            cls._pid = os.getpid()
+
+    os.register_at_fork(after_in_child=_reset_instances_lock)
+
+
+class _Cached(type):
+    """
+    Metaclass for caching file system instances.
+
+    Notes
+    -----
+    Instances are cached according to
+
+    * The values of the class attributes listed in `_extra_tokenize_attributes`
+    * The arguments passed to ``__init__``.
+
+    This creates an additional reference to the filesystem, which prevents the
+    filesystem from being garbage collected when all *user* references go away.
+    A call to the :meth:`AbstractFileSystem.clear_instance_cache` must *also*
+    be made for a filesystem instance to be garbage collected.
+    """
+
+    def __init__(cls, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        # Note: we intentionally create a reference here, to avoid garbage
+        # collecting instances when all other references are gone. To really
+        # delete a FileSystem, the cache must be cleared.
+        if conf.get("weakref_instance_cache"):  # pragma: no cover
+            # debug option for analysing fork/spawn conditions
+            cls._cache = weakref.WeakValueDictionary()
+        else:
+            cls._cache = {}
+        cls._pid = os.getpid()
+        cls._instantiation_lock = threading.RLock()
+
+        if FORK_AVAILABLE:
+            _registered_classes.add(cls)
+
+    def _check_instance_cache(cls, token):
+        inst = cls._cache.get(token)
+        if inst is not None:
+            cls._latest = token
+        return inst
+
+    def __call__(cls, *args, **kwargs):
+        kwargs = apply_config(cls, kwargs)
+        extra_tokens = tuple(
+            getattr(cls, attr, None) for attr in cls._extra_tokenize_attributes
+        )
+        strip_tokenize_options = {
+            k: kwargs.pop(k) for k in cls._strip_tokenize_options if k in kwargs
+        }
+        pid = os.getpid()
+
+        if getattr(cls, "async_impl", False) and not kwargs.get("asynchronous", False):
+            token = tokenize(cls, pid, *args, *extra_tokens, **kwargs)
+        else:
+            token = tokenize(
+                cls, pid, threading.get_ident(), *args, *extra_tokens, **kwargs
+            )
+        skip = kwargs.pop("skip_instance_cache", False)
+
+        if pid != cls._pid:
+            with cls._instantiation_lock:
+                if pid != cls._pid:
+                    cls._cache.clear()
+                    cls._pid = pid
+
+        if not skip and cls.cachable:
+            inst = cls._check_instance_cache(token)
+            if inst is not None:
+                return inst
+
+            with cls._instantiation_lock:
+                # protect against the race condition that a new instance was created
+                # and inserted into the cache since the initial check just above
+                inst = cls._check_instance_cache(token)
+                if inst is not None:
+                    return inst
+
+        obj = super().__call__(*args, **kwargs, **strip_tokenize_options)
+        # Setting _fs_token here causes some static linters to complain.
+        obj._fs_token_ = token
+        obj.storage_args = args
+        obj.storage_options = kwargs
+        if obj.async_impl and obj.mirror_sync_methods:
+            from .asyn import mirror_sync_methods
+
+            mirror_sync_methods(obj)
+
+        if cls.cachable and not skip:
+            with cls._instantiation_lock:
+                # another thread may have created the instance while we were calling
+                # super().__call__(), so we check again.
+                inst = cls._check_instance_cache(token)
+                if inst is not None:
+                    return inst
+
+                cls._latest = token
+                cls._cache[token] = obj
+        return obj
+
+
+class AbstractFileSystem(metaclass=_Cached):
+    """
+    An abstract super-class for pythonic file-systems
+
+    Implementations are expected to be compatible with or, better, subclass
+    from here.
+    """
+
+    cachable = True  # this class can be cached, instances reused
+    _cached = False
+    blocksize = 2**22
+    sep = "/"
+    # Implementations may select their protocol per instance (for example, a
+    # single adapter class backed by different storage implementations).
+    protocol: str | tuple[str, ...] = "abstract"
+    _latest = None
+    async_impl = False
+    mirror_sync_methods = False
+    root_marker = ""  # For some FSs, may require leading '/' or other character
+    transaction_type = Transaction
+
+    #: Extra *class attributes* that should be considered when hashing.
+    _extra_tokenize_attributes = ()
+    #: *storage options* that should not be considered when hashing.
+    _strip_tokenize_options = ()
+
+    # Set by _Cached metaclass
+    storage_args: tuple[Any, ...]
+    storage_options: dict[str, Any]
+
+    def __init__(self, *args, **storage_options):
+        """Create and configure file-system instance
+
+        Instances may be cachable, so if similar enough arguments are seen
+        a new instance is not required. The token attribute exists to allow
+        implementations to cache instances if they wish.
+
+        A reasonable default should be provided if there are no arguments.
+
+        Subclasses should call this method.
+
+        Parameters
+        ----------
+        use_listings_cache, listings_expiry_time, max_paths:
+            passed to ``DirCache``, if the implementation supports
+            directory listing caching. Pass use_listings_cache=False
+            to disable such caching.
+        skip_instance_cache: bool
+            If this is a cachable implementation, pass True here to force
+            creating a new instance even if a matching instance exists, and prevent
+            storing this instance.
+        asynchronous: bool
+        loop: asyncio-compatible IOLoop or None
+        """
+        if self._cached:
+            # reusing instance, don't change
+            return
+        self._cached = True
+        self._intrans = False
+        self._transaction = None
+        self._invalidated_caches_in_transaction = []
+        self.dircache = DirCache(**storage_options)
+
+        if storage_options.pop("add_docs", None):
+            warnings.warn("add_docs is no longer supported.", FutureWarning)
+
+        if storage_options.pop("add_aliases", None):
+            warnings.warn("add_aliases has been removed.", FutureWarning)
+        # This is set in _Cached
+        self._fs_token_ = None
+
+    @property
+    def fsid(self):
+        """Persistent filesystem id that can be used to compare filesystems
+        across sessions.
+        """
+        raise NotImplementedError
+
+    @property
+    def _fs_token(self):
+        return self._fs_token_
+
+    def __dask_tokenize__(self):
+        return self._fs_token
+
+    def __hash__(self):
+        return int(self._fs_token, 16)
+
+    def __eq__(self, other):
+        return isinstance(other, type(self)) and self._fs_token == other._fs_token
+
+    def __reduce__(self):
+        return make_instance, (type(self), self.storage_args, self.storage_options)
+
+    @classmethod
+    def _strip_protocol(cls, path):
+        """Turn path from fully-qualified to file-system-specific
+
+        May require FS-specific handling, e.g., for relative paths or links.
+        """
+        if isinstance(path, list):
+            return [cls._strip_protocol(p) for p in path]
+        path = stringify_path(path)
+        protos = (cls.protocol,) if isinstance(cls.protocol, str) else cls.protocol
+        for protocol in protos:
+            if path.startswith(protocol + "://"):
+                path = path[len(protocol) + 3 :]
+            elif path.startswith(protocol + "::"):
+                path = path[len(protocol) + 2 :]
+        path = path.rstrip("/")
+        # use of root_marker to make minimum required path, e.g., "/"
+        return path or cls.root_marker
+
+    def unstrip_protocol(self, name: str) -> str:
+        """Format FS-specific path to generic, including protocol"""
+        protos = (self.protocol,) if isinstance(self.protocol, str) else self.protocol
+        for protocol in protos:
+            if name.startswith(f"{protocol}://"):
+                return name
+        return f"{protos[0]}://{name}"
+
+    @staticmethod
+    def _get_kwargs_from_urls(path):
+        """If kwargs can be encoded in the paths, extract them here
+
+        This should happen before instantiation of the class; incoming paths
+        then should be amended to strip the options in methods.
+
+        Examples may look like an sftp path "sftp://user@host:/my/path", where
+        the user and host should become kwargs and later get stripped.
+        """
+        # by default, nothing happens
+        return {}
+
+    @classmethod
+    def current(cls):
+        """Return the most recently instantiated FileSystem
+
+        If no instance has been created, then create one with defaults
+        """
+        inst = cls._cache.get(cls._latest)
+        if inst is not None:
+            return inst
+        return cls()
+
+    @property
+    def transaction(self):
+        """A context within which files are committed together upon exit
+
+        Requires the file class to implement `.commit()` and `.discard()`
+        for the normal and exception cases.
+        """
+        if self._transaction is None:
+            self._transaction = self.transaction_type(self)
+        return self._transaction
+
+    def start_transaction(self):
+        """Begin write transaction for deferring files, non-context version"""
+        self._intrans = True
+        self._transaction = self.transaction_type(self)
+        return self.transaction
+
+    def end_transaction(self):
+        """Finish write transaction, non-context version"""
+        self.transaction.complete()
+        self._transaction = None
+        # The invalid cache must be cleared after the transaction is completed.
+        for path in self._invalidated_caches_in_transaction:
+            self.invalidate_cache(path)
+        self._invalidated_caches_in_transaction.clear()
+
+    def invalidate_cache(self, path=None):
+        """
+        Discard any cached directory information
+
+        Parameters
+        ----------
+        path: string or None
+            If None, clear all listings cached else listings at or under given
+            path.
+        """
+        # Not necessary to implement invalidation mechanism, may have no cache.
+        # But if have, you should call this method of parent class from your
+        # subclass to ensure expiring caches after transacations correctly.
+        # See the implementation of FTPFileSystem in ftp.py
+        if self._intrans:
+            self._invalidated_caches_in_transaction.append(path)
+
+    def mkdir(self, path, create_parents=True, **kwargs):
+        """
+        Create directory entry at path
+
+        For systems that don't have true directories, may create an for
+        this instance only and not touch the real filesystem
+
+        Parameters
+        ----------
+        path: str
+            location
+        create_parents: bool
+            if True, this is equivalent to ``makedirs``
+        kwargs:
+            may be permissions, etc.
+        """
+        pass  # not necessary to implement, may not have directories
+
+    def makedirs(self, path, exist_ok=False):
+        """Recursively make directories
+
+        Creates directory at path and any intervening required directories.
+        Raises exception if, for instance, the path already exists but is a
+        file.
+
+        Parameters
+        ----------
+        path: str
+            leaf directory name
+        exist_ok: bool (False)
+            If False, will error if the target already exists
+        """
+        pass  # not necessary to implement, may not have directories
+
+    def rmdir(self, path):
+        """Remove a directory, if empty"""
+        pass  # not necessary to implement, may not have directories
+
+    def ls(self, path, detail=True, **kwargs):
+        """List objects at path.
+
+        This should include subdirectories and files at that location. The
+        difference between a file and a directory must be clear when details
+        are requested.
+
+        The specific keys, or perhaps a FileInfo class, or similar, is TBD,
+        but must be consistent across implementations.
+        Must include:
+
+        - full path to the entry (without protocol)
+        - size of the entry, in bytes. If the value cannot be determined, will
+          be ``None``.
+        - type of entry, "file", "directory" or other
+
+        Additional information
+        may be present, appropriate to the file-system, e.g., generation,
+        checksum, etc.
+
+        May use refresh=True|False to allow use of self._ls_from_cache to
+        check for a saved listing and avoid calling the backend. This would be
+        common where listing may be expensive.
+
+        Parameters
+        ----------
+        path: str
+        detail: bool
+            if True, gives a list of dictionaries, where each is the same as
+            the result of ``info(path)``. If False, gives a list of paths
+            (str).
+        kwargs: may have additional backend-specific options, such as version
+            information
+
+        Returns
+        -------
+        List of strings if detail is False, or list of directory information
+        dicts if detail is True.
+        """
+        raise NotImplementedError
+
+    def _ls_from_cache(self, path):
+        """Check cache for listing
+
+        Returns listing, if found (may be empty list for a directly that exists
+        but contains nothing), None if not in cache.
+        """
+        parent = self._parent(path)
+        try:
+            return self.dircache[path.rstrip("/")]
+        except KeyError:
+            pass
+        try:
+            files = [
+                f
+                for f in self.dircache[parent]
+                if f["name"] == path
+                or (f["name"] == path.rstrip("/") and f["type"] == "directory")
+            ]
+            if len(files) == 0:
+                # parent dir was listed but did not contain this file
+                raise FileNotFoundError(path)
+            return files
+        except KeyError:
+            pass
+
+    def walk(self, path, maxdepth=None, topdown=True, on_error="omit", **kwargs):
+        """Return all files under the given path.
+
+        List all files, recursing into subdirectories; output is iterator-style,
+        like ``os.walk()``. For a simple list of files, ``find()`` is available.
+
+        When topdown is True, the caller can modify the dirnames list in-place (perhaps
+        using del or slice assignment), and walk() will
+        only recurse into the subdirectories whose names remain in dirnames;
+        this can be used to prune the search, impose a specific order of visiting,
+        or even to inform walk() about directories the caller creates or renames before
+        it resumes walk() again.
+        Modifying dirnames when topdown is False has no effect. (see os.walk)
+
+        Note that the "files" outputted will include anything that is not
+        a directory, such as links.
+
+        Parameters
+        ----------
+        path: str
+            Root to recurse into
+        maxdepth: int
+            Maximum recursion depth. None means limitless, but not recommended
+            on link-based file-systems.
+        topdown: bool (True)
+            Whether to walk the directory tree from the top downwards or from
+            the bottom upwards.
+        on_error: "omit", "raise", a callable
+            if omit (default), path with exception will simply be empty;
+            If raise, an underlying exception will be raised;
+            if callable, it will be called with a single OSError instance as argument
+        kwargs: passed to ``ls``
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        path = self._strip_protocol(path)
+        full_dirs = {}
+        dirs = {}
+        files = {}
+
+        detail = kwargs.pop("detail", False)
+        try:
+            listing = self.ls(path, detail=True, **kwargs)
+        except (FileNotFoundError, OSError) as e:
+            if on_error == "raise":
+                raise
+            if callable(on_error):
+                on_error(e)
+            return
+
+        for info in listing:
+            # each info name must be at least [path]/part , but here
+            # we check also for names like [path]/part/
+            pathname = info["name"].rstrip("/")
+            name = pathname.rsplit("/", 1)[-1]
+            if info["type"] == "directory" and pathname != path:
+                # do not include "self" path
+                full_dirs[name] = pathname
+                dirs[name] = info
+            elif pathname == path:
+                # file-like with same name as give path
+                files[""] = info
+            else:
+                files[name] = info
+
+        if not detail:
+            dirs = list(dirs)
+            files = list(files)
+
+        if topdown:
+            # Yield before recursion if walking top down
+            yield path, dirs, files
+
+        if maxdepth is not None:
+            maxdepth -= 1
+            if maxdepth < 1:
+                if not topdown:
+                    yield path, dirs, files
+                return
+
+        for d in dirs:
+            yield from self.walk(
+                full_dirs[d],
+                maxdepth=maxdepth,
+                detail=detail,
+                topdown=topdown,
+                **kwargs,
+            )
+
+        if not topdown:
+            # Yield after recursion if walking bottom up
+            yield path, dirs, files
+
+    def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs):
+        """List all files below path.
+
+        Like posix ``find`` command without conditions
+
+        Parameters
+        ----------
+        path : str
+        maxdepth: int or None
+            If not None, the maximum number of levels to descend
+        withdirs: bool
+            Whether to include directory paths in the output. This is True
+            when used by glob, but users usually only want files.
+        kwargs are passed to ``ls``.
+        """
+        # TODO: allow equivalent of -name parameter
+        path = self._strip_protocol(path)
+        out = {}
+
+        # Add the root directory if withdirs is requested
+        # This is needed for posix glob compliance
+        if withdirs and path != "" and self.isdir(path):
+            out[path] = self.info(path)
+
+        for _, dirs, files in self.walk(path, maxdepth, detail=True, **kwargs):
+            if withdirs:
+                files.update(dirs)
+            out.update({info["name"]: info for name, info in files.items()})
+        if not out and self.isfile(path):
+            # walk works on directories, but find should also return [path]
+            # when path happens to be a file
+            out[path] = {}
+        names = sorted(out)
+        if not detail:
+            return names
+        else:
+            return {name: out[name] for name in names}
+
+    def du(self, path, total=True, maxdepth=None, withdirs=False, **kwargs):
+        """Space used by files and optionally directories within a path
+
+        Directory size does not include the size of its contents.
+
+        Parameters
+        ----------
+        path: str
+        total: bool
+            Whether to sum all the file sizes
+        maxdepth: int or None
+            Maximum number of directory levels to descend, None for unlimited.
+        withdirs: bool
+            Whether to include directory paths in the output.
+        kwargs: passed to ``find``
+
+        Returns
+        -------
+        Dict of {path: size} if total=False, or int otherwise, where numbers
+        refer to bytes used.
+        """
+        sizes = {}
+        if withdirs and self.isdir(path):
+            # Include top-level directory in output
+            info = self.info(path)
+            sizes[info["name"]] = info["size"]
+        for f in self.find(path, maxdepth=maxdepth, withdirs=withdirs, **kwargs):
+            info = self.info(f)
+            sizes[info["name"]] = info["size"]
+        if total:
+            return sum(sizes.values())
+        else:
+            return sizes
+
+    def glob(self, path, maxdepth=None, **kwargs):
+        """Find files by glob-matching.
+
+        Pattern matching capabilities for finding files that match the given pattern.
+
+        Parameters
+        ----------
+        path: str
+            The glob pattern to match against
+        maxdepth: int or None
+            Maximum depth for ``'**'`` patterns. Applied on the first ``'**'`` found.
+            Must be at least 1 if provided.
+        kwargs:
+            Additional arguments passed to ``find`` (e.g., detail=True)
+
+        Returns
+        -------
+        List of matched paths, or dict of paths and their info if detail=True
+
+        Notes
+        -----
+        Supported patterns:
+        - '*': Matches any sequence of characters within a single directory level
+        - ``'**'``: Matches any number of directory levels (must be an entire path component)
+        - '?': Matches exactly one character
+        - '[abc]': Matches any character in the set
+        - '[a-z]': Matches any character in the range
+        - '[!abc]': Matches any character NOT in the set
+
+        Special behaviors:
+        - If the path ends with '/', only folders are returned
+        - Consecutive '*' characters are compressed into a single '*'
+        - Empty set '[]' or negated empty negated set '[!]' never match anything
+        - Special characters in character classes are escaped properly
+
+        Limitations:
+        - ``'**'`` must be a complete path component (e.g., ``'a/**/b'``, not ``'a**b'``)
+        - No brace expansion ('{a,b}.txt')
+        - No extended glob patterns ('+(pattern)', '!(pattern)')
+        """
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        import re
+
+        seps = (os.path.sep, os.path.altsep) if os.path.altsep else (os.path.sep,)
+        ends_with_sep = path.endswith(seps)  # _strip_protocol strips trailing slash
+        path = self._strip_protocol(path)
+        append_slash_to_dirname = ends_with_sep or path.endswith(
+            tuple(sep + "**" for sep in seps)
+        )
+        idx_star = path.find("*") if path.find("*") >= 0 else len(path)
+        idx_qmark = path.find("?") if path.find("?") >= 0 else len(path)
+        idx_brace = path.find("[") if path.find("[") >= 0 else len(path)
+
+        min_idx = min(idx_star, idx_qmark, idx_brace)
+
+        detail = kwargs.pop("detail", False)
+        withdirs = kwargs.pop("withdirs", True)
+
+        if not has_magic(path):
+            if self.exists(path, **kwargs):
+                if not detail:
+                    return [path]
+                else:
+                    return {path: self.info(path, **kwargs)}
+            else:
+                if not detail:
+                    return []  # glob of non-existent returns empty
+                else:
+                    return {}
+        elif "/" in path[:min_idx]:
+            min_idx = path[:min_idx].rindex("/")
+            root = path[: min_idx + 1]
+            depth = path[min_idx + 1 :].count("/") + 1
+        else:
+            root = ""
+            depth = path[min_idx + 1 :].count("/") + 1
+
+        if "**" in path:
+            if maxdepth is not None:
+                idx_double_stars = path.find("**")
+                depth_double_stars = path[idx_double_stars:].count("/") + 1
+                depth = depth - depth_double_stars + maxdepth
+            else:
+                depth = None
+
+        allpaths = self.find(
+            root, maxdepth=depth, withdirs=withdirs, detail=True, **kwargs
+        )
+
+        pattern = glob_translate(path + ("/" if ends_with_sep else ""))
+        pattern = re.compile(pattern)
+
+        out = {
+            p: info
+            for p, info in sorted(allpaths.items())
+            if pattern.match(
+                p + "/"
+                if append_slash_to_dirname and info["type"] == "directory"
+                else p
+            )
+        }
+
+        if detail:
+            return out
+        else:
+            return list(out)
+
+    def exists(self, path, **kwargs):
+        """Is there a file at the given path"""
+        try:
+            self.info(path, **kwargs)
+            return True
+        except:  # noqa: E722
+            # any exception allowed bar FileNotFoundError?
+            return False
+
+    def lexists(self, path, **kwargs):
+        """If there is a file at the given path (including
+        broken links)"""
+        return self.exists(path)
+
+    def info(self, path, **kwargs):
+        """Give details of entry at path
+
+        Returns a single dictionary, with exactly the same information as ``ls``
+        would with ``detail=True``.
+
+        The default implementation calls ls and could be overridden by a
+        shortcut. kwargs are passed on to ```ls()``.
+
+        Some file systems might not be able to measure the file's size, in
+        which case, the returned dict will include ``'size': None``.
+
+        Returns
+        -------
+        dict with keys: name (full path in the FS), size (in bytes), type (file,
+        directory, or something else) and other FS-specific keys.
+        """
+        path = self._strip_protocol(path)
+        out = self.ls(self._parent(path), detail=True, **kwargs)
+        out = [o for o in out if o["name"].rstrip("/") == path]
+        if out:
+            return out[0]
+        out = self.ls(path, detail=True, **kwargs)
+        path = path.rstrip("/")
+        out1 = [o for o in out if o["name"].rstrip("/") == path]
+        if len(out1) == 1:
+            if "size" not in out1[0]:
+                out1[0]["size"] = None
+            return out1[0]
+        elif len(out1) > 1 or out:
+            return {"name": path, "size": 0, "type": "directory"}
+        else:
+            raise FileNotFoundError(path)
+
+    def checksum(self, path):
+        """Unique value for current version of file
+
+        If the checksum is the same from one moment to another, the contents
+        are guaranteed to be the same. If the checksum changes, the contents
+        *might* have changed.
+
+        This should normally be overridden; default will probably capture
+        creation/modification timestamp (which would be good) or maybe
+        access timestamp (which would be bad)
+        """
+        return int(tokenize(self.info(path)), 16)
+
+    def size(self, path):
+        """Size in bytes of file"""
+        return self.info(path).get("size", None)
+
+    def sizes(self, paths):
+        """Size in bytes of each file in a list of paths"""
+        return [self.size(p) for p in paths]
+
+    def isdir(self, path):
+        """Is this entry directory-like?"""
+        try:
+            return self.info(path)["type"] == "directory"
+        except OSError:
+            return False
+
+    def isfile(self, path):
+        """Is this entry file-like?"""
+        try:
+            return self.info(path)["type"] == "file"
+        except Exception:
+            return False
+
+    def read_text(self, path, encoding=None, errors=None, newline=None, **kwargs):
+        """Get the contents of the file as a string.
+
+        Parameters
+        ----------
+        path: str
+            URL of file on this filesystems
+        encoding, errors, newline: same as `open`.
+        """
+        with self.open(
+            path,
+            mode="r",
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            **kwargs,
+        ) as f:
+            return f.read()
+
+    def write_text(
+        self, path, value, encoding=None, errors=None, newline=None, **kwargs
+    ):
+        """Write the text to the given file.
+
+        An existing file will be overwritten.
+
+        Parameters
+        ----------
+        path: str
+            URL of file on this filesystems
+        value: str
+            Text to write.
+        encoding, errors, newline: same as `open`.
+        """
+        with self.open(
+            path,
+            mode="w",
+            encoding=encoding,
+            errors=errors,
+            newline=newline,
+            **kwargs,
+        ) as f:
+            return f.write(value)
+
+    def cat_file(self, path, start=None, end=None, **kwargs):
+        """Get the content of a file
+
+        Parameters
+        ----------
+        path: URL of file on this filesystems
+        start, end: int
+            Bytes limits of the read. If negative, backwards from end,
+            like usual python slices. Either can be None for start or
+            end of file, respectively
+        kwargs: passed to ``open()``.
+        """
+        # explicitly set buffering off?
+        with self.open(path, "rb", **kwargs) as f:
+            if start is not None:
+                if start >= 0:
+                    f.seek(start)
+                else:
+                    f.seek(max(0, f.size + start))
+            if end is not None:
+                if end < 0:
+                    end = f.size + end
+                return f.read(end - f.tell())
+            return f.read()
+
+    def pipe_file(self, path, value, mode="overwrite", **kwargs):
+        """Set the bytes of given file"""
+        if mode == "create" and self.exists(path):
+            # non-atomic but simple way; or could use "xb" in open(), which is likely
+            # not as well supported
+            raise FileExistsError
+        with self.open(path, "wb", **kwargs) as f:
+            f.write(value)
+
+    def pipe(self, path, value=None, **kwargs):
+        """Put value into path
+
+        (counterpart to ``cat``)
+
+        Parameters
+        ----------
+        path: string or dict(str, bytes)
+            If a string, a single remote location to put ``value`` bytes; if a dict,
+            a mapping of {path: bytesvalue}.
+        value: bytes, optional
+            If using a single path, these are the bytes to put there. Ignored if
+            ``path`` is a dict
+        """
+        if isinstance(path, str):
+            self.pipe_file(self._strip_protocol(path), value, **kwargs)
+        elif isinstance(path, dict):
+            for k, v in path.items():
+                self.pipe_file(self._strip_protocol(k), v, **kwargs)
+        else:
+            raise ValueError("path must be str or dict")
+
+    def cat_ranges(
+        self, paths, starts, ends, max_gap=None, on_error="return", **kwargs
+    ):
+        """Get the contents of byte ranges from one or more files
+
+        Parameters
+        ----------
+        paths: list
+            A list of of filepaths on this filesystems
+        starts, ends: int or list
+            Bytes limits of the read. If using a single int, the same value will be
+            used to read all the specified files.
+        """
+        if max_gap is not None:
+            raise NotImplementedError
+        if not isinstance(paths, list):
+            raise TypeError
+        if not isinstance(starts, list):
+            starts = [starts] * len(paths)
+        if not isinstance(ends, list):
+            ends = [ends] * len(paths)
+        if len(starts) != len(paths) or len(ends) != len(paths):
+            raise ValueError
+        out = []
+        for p, s, e in zip(paths, starts, ends):
+            try:
+                out.append(self.cat_file(p, s, e, **kwargs))
+            except Exception as e:
+                if on_error == "return":
+                    out.append(e)
+                else:
+                    raise
+        return out
+
+    def cat(self, path, recursive=False, on_error="raise", **kwargs):
+        """Fetch (potentially multiple) paths' contents
+
+        Parameters
+        ----------
+        recursive: bool
+            If True, assume the path(s) are directories, and get all the
+            contained files
+        on_error : "raise", "omit", "return"
+            If raise, an underlying exception will be raised (converted to KeyError
+            if the type is in self.missing_exceptions); if omit, keys with exception
+            will simply not be included in the output; if "return", all keys are
+            included in the output, but the value will be bytes or an exception
+            instance.
+        kwargs: passed to cat_file
+
+        Returns
+        -------
+        dict of {path: contents} if there are multiple paths
+        or the path has been otherwise expanded
+        """
+        paths = self.expand_path(path, recursive=recursive, **kwargs)
+        if (
+            len(paths) > 1
+            or isinstance(path, list)
+            or paths[0] != self._strip_protocol(path)
+        ):
+            out = {}
+            for path in paths:
+                try:
+                    out[path] = self.cat_file(path, **kwargs)
+                except Exception as e:
+                    if on_error == "raise":
+                        raise
+                    if on_error == "return":
+                        out[path] = e
+            return out
+        else:
+            return self.cat_file(paths[0], **kwargs)
+
+    def get_file(
+        self, rpath, lpath=None, callback=DEFAULT_CALLBACK, outfile=None, **kwargs
+    ):
+        """Copy single remote file to local"""
+        from .implementations.local import LocalFileSystem
+
+        if outfile is None and isfilelike(lpath):
+            outfile = lpath
+        elif outfile is None and self.isdir(rpath):
+            os.makedirs(lpath, exist_ok=True)
+            return None
+
+        if outfile is None:
+            fs = LocalFileSystem(auto_mkdir=True)
+            fs.makedirs(fs._parent(lpath), exist_ok=True)
+
+        with self.open(rpath, "rb", **kwargs) as f1:
+            close_outfile = outfile is None
+            if close_outfile:
+                outfile = open(lpath, "wb")
+
+            try:
+                callback.set_size(getattr(f1, "size", None))
+                data = True
+                while data:
+                    data = f1.read(self.blocksize)
+                    segment_len = outfile.write(data)
+                    if segment_len is None:
+                        segment_len = len(data)
+                    callback.relative_update(segment_len)
+            finally:
+                if close_outfile:
+                    outfile.close()
+
+    def get(
+        self,
+        rpath,
+        lpath,
+        recursive=False,
+        callback=DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) to local.
+
+        Copies a specific file or tree of files (if recursive=True). If lpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within. Can submit a list of paths, which may be glob-patterns
+        and will be expanded.
+
+        Calls get_file for each source.
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            from .implementations.local import (
+                LocalFileSystem,
+                make_path_posix,
+                trailing_sep,
+            )
+
+            source_is_str = isinstance(rpath, str)
+            rpaths = self.expand_path(
+                rpath, recursive=recursive, maxdepth=maxdepth, **kwargs
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                rpaths = [p for p in rpaths if not (trailing_sep(p) or self.isdir(p))]
+                if not rpaths:
+                    return
+
+            if isinstance(lpath, str):
+                lpath = make_path_posix(lpath)
+
+            source_is_file = len(rpaths) == 1
+            dest_is_dir = isinstance(lpath, str) and (
+                trailing_sep(lpath) or LocalFileSystem().isdir(lpath)
+            )
+
+            exists = source_is_str and (
+                (has_magic(rpath) and source_is_file)
+                or (not has_magic(rpath) and dest_is_dir and not trailing_sep(rpath))
+            )
+            lpaths = other_paths(
+                rpaths,
+                lpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+            if isinstance(lpath, str):
+                # The names came from the source listing; ".." in one of them
+                # would otherwise place the copy above the destination. When
+                # lpath is a list the caller named every destination itself.
+                check_contained(lpath, lpaths)
+
+        callback.set_size(len(lpaths))
+        for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+            with callback.branched(rpath, lpath) as child:
+                self.get_file(rpath, lpath, callback=child, **kwargs)
+
+    def put_file(
+        self, lpath, rpath, callback=DEFAULT_CALLBACK, mode="overwrite", **kwargs
+    ):
+        """Copy single file to remote"""
+        if mode == "create" and self.exists(rpath):
+            raise FileExistsError
+        if os.path.isdir(lpath):
+            self.makedirs(rpath, exist_ok=True)
+            return None
+
+        with open(lpath, "rb") as f1:
+            size = f1.seek(0, 2)
+            callback.set_size(size)
+            f1.seek(0)
+
+            self.mkdirs(self._parent(os.fspath(rpath)), exist_ok=True)
+            with self.open(rpath, "wb", **kwargs) as f2:
+                while f1.tell() < size:
+                    data = f1.read(self.blocksize)
+                    segment_len = f2.write(data)
+                    if segment_len is None:
+                        segment_len = len(data)
+                    callback.relative_update(segment_len)
+
+    def put(
+        self,
+        lpath,
+        rpath,
+        recursive=False,
+        callback=DEFAULT_CALLBACK,
+        maxdepth=None,
+        **kwargs,
+    ):
+        """Copy file(s) from local.
+
+        Copies a specific file or tree of files (if recursive=True). If rpath
+        ends with a "/", it will be assumed to be a directory, and target files
+        will go within.
+
+        Calls put_file for each source.
+        """
+        if isinstance(lpath, list) and isinstance(rpath, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            rpaths = rpath
+            lpaths = lpath
+        else:
+            from .implementations.local import (
+                LocalFileSystem,
+                make_path_posix,
+                trailing_sep,
+            )
+
+            source_is_str = isinstance(lpath, str)
+            if source_is_str:
+                lpath = make_path_posix(lpath)
+            fs = LocalFileSystem()
+            lpaths = fs.expand_path(
+                lpath, recursive=recursive, maxdepth=maxdepth, **kwargs
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                lpaths = [p for p in lpaths if not (trailing_sep(p) or fs.isdir(p))]
+                if not lpaths:
+                    return
+
+            source_is_file = len(lpaths) == 1
+            dest_is_dir = isinstance(rpath, str) and (
+                trailing_sep(rpath) or self.isdir(rpath)
+            )
+
+            rpath = (
+                self._strip_protocol(rpath)
+                if isinstance(rpath, str)
+                else [self._strip_protocol(p) for p in rpath]
+            )
+            exists = source_is_str and (
+                (has_magic(lpath) and source_is_file)
+                or (not has_magic(lpath) and dest_is_dir and not trailing_sep(lpath))
+            )
+            rpaths = other_paths(
+                lpaths,
+                rpath,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        callback.set_size(len(rpaths))
+        for lpath, rpath in callback.wrap(zip(lpaths, rpaths)):
+            with callback.branched(lpath, rpath) as child:
+                self.put_file(lpath, rpath, callback=child, **kwargs)
+
+    def head(self, path, size=1024):
+        """Get the first ``size`` bytes from file"""
+        with self.open(path, "rb") as f:
+            return f.read(size)
+
+    def tail(self, path, size=1024):
+        """Get the last ``size`` bytes from file"""
+        with self.open(path, "rb") as f:
+            f.seek(0, 2)
+            f.seek(max(f.tell() - size, 0))
+            return f.read()
+
+    def cp_file(self, path1, path2, **kwargs):
+        raise NotImplementedError
+
+    def copy(
+        self, path1, path2, recursive=False, maxdepth=None, on_error=None, **kwargs
+    ):
+        """Copy within two locations in the filesystem
+
+        on_error : "raise", "ignore"
+            If raise, any not-found exceptions will be raised; if ignore any
+            not-found exceptions will cause the path to be skipped; defaults to
+            raise unless recursive is true, where the default is ignore
+        """
+        if on_error is None and recursive:
+            on_error = "ignore"
+        elif on_error is None:
+            on_error = "raise"
+
+        if isinstance(path1, list) and isinstance(path2, list):
+            # No need to expand paths when both source and destination
+            # are provided as lists
+            paths1 = path1
+            paths2 = path2
+        else:
+            from .implementations.local import trailing_sep
+
+            source_is_str = isinstance(path1, str)
+            paths1 = self.expand_path(
+                path1, recursive=recursive, maxdepth=maxdepth, **kwargs
+            )
+            if source_is_str and (not recursive or maxdepth is not None):
+                # Non-recursive glob does not copy directories
+                paths1 = [p for p in paths1 if not (trailing_sep(p) or self.isdir(p))]
+                if not paths1:
+                    return
+
+            source_is_file = len(paths1) == 1
+            dest_is_dir = isinstance(path2, str) and (
+                trailing_sep(path2) or self.isdir(path2)
+            )
+
+            exists = source_is_str and (
+                (has_magic(path1) and source_is_file)
+                or (not has_magic(path1) and dest_is_dir and not trailing_sep(path1))
+            )
+            paths2 = other_paths(
+                paths1,
+                path2,
+                exists=exists,
+                flatten=not source_is_str,
+            )
+
+        for p1, p2 in zip(paths1, paths2):
+            try:
+                self.cp_file(p1, p2, **kwargs)
+            except FileNotFoundError:
+                if on_error == "raise":
+                    raise
+
+    def expand_path(
+        self, path, recursive=False, maxdepth=None, assume_literal=False, **kwargs
+    ):
+        """Turn one or more globs or directories into a list of all matching paths
+        to files or directories.
+
+        kwargs are passed to ``glob`` or ``find``, which may in turn call ``ls``
+        """
+
+        if maxdepth is not None and maxdepth < 1:
+            raise ValueError("maxdepth must be at least 1")
+
+        if isinstance(path, (str, os.PathLike)):
+            out = self.expand_path([path], recursive, maxdepth, **kwargs)
+        else:
+            out = set()
+            path = [self._strip_protocol(p) for p in path]
+            for p in path:
+                if not assume_literal and has_magic(p):
+                    bit = set(self.glob(p, maxdepth=maxdepth, **kwargs))
+                    out |= bit
+                    if recursive:
+                        # glob call above expanded one depth so if maxdepth is defined
+                        # then decrement it in expand_path call below. If it is zero
+                        # after decrementing then avoid expand_path call.
+                        if maxdepth is not None and maxdepth <= 1:
+                            continue
+                        out |= set(
+                            self.expand_path(
+                                list(bit),
+                                recursive=recursive,
+                                maxdepth=maxdepth - 1 if maxdepth is not None else None,
+                                assume_literal=True,
+                                **kwargs,
+                            )
+                        )
+                    continue
+                elif recursive:
+                    rec = set(
+                        self.find(
+                            p, maxdepth=maxdepth, withdirs=True, detail=False, **kwargs
+                        )
+                    )
+                    out |= rec
+                if p not in out and (recursive is False or self.exists(p)):
+                    # should only check once, for the root
+                    out.add(p)
+        if not out:
+            raise FileNotFoundError(path)
+        return sorted(out)
+
+    def mv(self, path1, path2, recursive=False, maxdepth=None, **kwargs):
+        """Move file(s) from one location to another"""
+        if path1 == path2:
+            logger.debug("%s mv: The paths are the same, so no files were moved.", self)
+        else:
+            # explicitly raise exception to prevent data corruption
+            self.copy(
+                path1, path2, recursive=recursive, maxdepth=maxdepth, on_error="raise"
+            )
+            self.rm(path1, recursive=recursive)
+
+    def rm_file(self, path):
+        """Delete a file"""
+        self._rm(path)
+
+    def _rm(self, path):
+        """Delete one file"""
+        # this is the old name for the method, prefer rm_file
+        raise NotImplementedError
+
+    def rm(self, path, recursive=False, maxdepth=None):
+        """Delete files or directories.
+
+        Parameters
+        ----------
+        path: str or list of str
+            Files or directories to delete.
+        recursive: bool
+            If True, recursively delete directories and their contents.
+        maxdepth: int or None
+            Depth to pass to walk for finding files to delete, if recursive.
+            If None, there will be no limit and infinite recursion may be
+            possible.
+        """
+        path = self.expand_path(path, recursive=recursive, maxdepth=maxdepth)
+        for p in reversed(path):
+            self.rm_file(p)
+
+    @classmethod
+    def _parent(cls, path):
+        path = cls._strip_protocol(path)
+        if "/" in path:
+            parent = path.rsplit("/", 1)[0].lstrip(cls.root_marker)
+            return cls.root_marker + parent
+        else:
+            return cls.root_marker
+
+    def _open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        autocommit=True,
+        cache_options=None,
+        **kwargs,
+    ):
+        """Return raw bytes-mode file-like from the file-system"""
+        return AbstractBufferedFile(
+            self,
+            path,
+            mode,
+            block_size,
+            autocommit,
+            cache_options=cache_options,
+            **kwargs,
+        )
+
+    def open(
+        self,
+        path,
+        mode="rb",
+        block_size=None,
+        cache_options=None,
+        compression=None,
+        **kwargs,
+    ):
+        """
+        Return a file-like object from the filesystem
+
+        The resultant instance must function correctly in a context ``with``
+        block.
+
+        Parameters
+        ----------
+        path: str
+            Target file
+        mode: str like 'rb', 'w'
+            See builtin ``open()``
+            Mode "x" (exclusive write) may be implemented by the backend. Even if
+            it is, whether  it is checked up front or on commit, and whether it is
+            atomic is implementation-dependent.
+        block_size: int
+            Some indication of buffering - this is a value in bytes
+        cache_options : dict, optional
+            Extra arguments to pass through to the cache.
+        compression: string or None
+            If given, open file using compression codec. Can either be a compression
+            name (a key in ``fsspec.compression.compr``) or "infer" to guess the
+            compression from the filename suffix.
+        encoding, errors, newline: passed on to TextIOWrapper for text mode
+        """
+        import io
+
+        path = self._strip_protocol(path)
+        if "b" not in mode:
+            mode = mode.replace("t", "") + "b"
+
+            text_kwargs = {
+                k: kwargs.pop(k)
+                for k in ["encoding", "errors", "newline"]
+                if k in kwargs
+            }
+            return io.TextIOWrapper(
+                self.open(
+                    path,
+                    mode,
+                    block_size=block_size,
+                    cache_options=cache_options,
+                    compression=compression,
+                    **kwargs,
+                ),
+                **text_kwargs,
+            )
+        else:
+            ac = kwargs.pop("autocommit", not self._intrans)
+            f = self._open(
+                path,
+                mode=mode,
+                block_size=block_size,
+                autocommit=ac,
+                cache_options=cache_options,
+                **kwargs,
+            )
+            if not ac and "r" not in mode:
+                self.transaction.files.append(f)
+            if compression is not None:
+                from fsspec.compression import compr
+                from fsspec.core import get_compression
+
+                compression = get_compression(path, compression)
+                compress = compr[compression]
+                f = compress(f, mode=mode[0])
+            return f
+
+    def touch(self, path, truncate=True, **kwargs):
+        """Create empty file, or update timestamp
+
+        Parameters
+        ----------
+        path: str
+            file location
+        truncate: bool
+            If True, always set file size to 0; if False, update timestamp and
+            leave file unchanged, if backend allows this
+        """
+        if truncate or not self.exists(path):
+            with self.open(path, "wb", **kwargs):
+                pass
+        else:
+            raise NotImplementedError  # update timestamp, if possible
+
+    def ukey(self, path):
+        """Hash of file properties, to tell if it has changed"""
+        return sha256(str(self.info(path)).encode()).hexdigest()
+
+    def read_block(self, fn, offset, length, delimiter=None):
+        """Read a block of bytes from
+
+        Starting at ``offset`` of the file, read ``length`` bytes.  If
+        ``delimiter`` is set then we ensure that the read starts and stops at
+        delimiter boundaries that follow the locations ``offset`` and ``offset
+        + length``.  If ``offset`` is zero then we start at zero.  The
+        bytestring returned WILL include the end delimiter string.
+
+        If offset+length is beyond the eof, reads to eof.
+
+        Parameters
+        ----------
+        fn: string
+            Path to filename
+        offset: int
+            Byte offset to start read
+        length: int
+            Number of bytes to read. If None, read to end.
+        delimiter: bytes (optional)
+            Ensure reading starts and stops at delimiter bytestring
+
+        Examples
+        --------
+        >>> fs.read_block('data/file.csv', 0, 13)  # doctest: +SKIP
+        b'Alice, 100\\nBo'
+        >>> fs.read_block('data/file.csv', 0, 13, delimiter=b'\\n')  # doctest: +SKIP
+        b'Alice, 100\\nBob, 200\\n'
+
+        Use ``length=None`` to read to the end of the file.
+        >>> fs.read_block('data/file.csv', 0, None, delimiter=b'\\n')  # doctest: +SKIP
+        b'Alice, 100\\nBob, 200\\nCharlie, 300'
+
+        See Also
+        --------
+        :func:`fsspec.utils.read_block`
+        """
+        with self.open(fn, "rb") as f:
+            size = f.size
+            if length is None:
+                length = size
+            if size is not None and offset + length > size:
+                length = size - offset
+            return read_block(f, offset, length, delimiter)
+
+    def to_json(self, *, include_password: bool = True) -> str:
+        """
+        JSON representation of this filesystem instance.
+
+        Parameters
+        ----------
+        include_password: bool, default True
+            Whether to include the password (if any) in the output.
+
+        Returns
+        -------
+        JSON string with keys ``cls`` (the python location of this class),
+        protocol (text name of this class's protocol, first one in case of
+        multiple), ``args`` (positional args, usually empty), and all other
+        keyword arguments as their own keys.
+
+        Warnings
+        --------
+        Serialized filesystems may contain sensitive information which have been
+        passed to the constructor, such as passwords and tokens. Make sure you
+        store and send them in a secure environment!
+        """
+        from .json import FilesystemJSONEncoder
+
+        return json.dumps(
+            self,
+            cls=type(
+                "_FilesystemJSONEncoder",
+                (FilesystemJSONEncoder,),
+                {"include_password": include_password},
+            ),
+        )
+
+    @staticmethod
+    def from_json(blob: str) -> AbstractFileSystem:
+        """
+        Recreate a filesystem instance from JSON representation.
+
+        See ``.to_json()`` for the expected structure of the input.
+
+        Parameters
+        ----------
+        blob: str
+
+        Returns
+        -------
+        file system instance, not necessarily of this particular class.
+
+        Warnings
+        --------
+        This can import arbitrary modules (as determined by the ``cls`` key).
+        Make sure you haven't installed any modules that may execute malicious code
+        at import time.
+        """
+        from .json import FilesystemJSONDecoder
+
+        return json.loads(blob, cls=FilesystemJSONDecoder)
+
+    def to_dict(self, *, include_password: bool = True) -> dict[str, Any]:
+        """
+        JSON-serializable dictionary representation of this filesystem instance.
+
+        Parameters
+        ----------
+        include_password: bool, default True
+            Whether to include the password (if any) in the output.
+
+        Returns
+        -------
+        Dictionary with keys ``cls`` (the python location of this class),
+        protocol (text name of this class's protocol, first one in case of
+        multiple), ``args`` (positional args, usually empty), and all other
+        keyword arguments as their own keys.
+
+        Warnings
+        --------
+        Serialized filesystems may contain sensitive information which have been
+        passed to the constructor, such as passwords and tokens. Make sure you
+        store and send them in a secure environment!
+        """
+        from .json import FilesystemJSONEncoder
+
+        json_encoder = FilesystemJSONEncoder()
+
+        cls = type(self)
+        proto = self.protocol
+
+        storage_options = dict(self.storage_options)
+        if not include_password:
+            storage_options.pop("password", None)
+
+        return dict(
+            cls=f"{cls.__module__}:{cls.__name__}",
+            protocol=proto[0] if isinstance(proto, (tuple, list)) else proto,
+            args=json_encoder.make_serializable(self.storage_args),
+            **json_encoder.make_serializable(storage_options),
+        )
+
+    @staticmethod
+    def from_dict(dct: dict[str, Any]) -> AbstractFileSystem:
+        """
+        Recreate a filesystem instance from dictionary representation.
+
+        See ``.to_dict()`` for the expected structure of the input.
+
+        Parameters
+        ----------
+        dct: Dict[str, Any]
+
+        Returns
+        -------
+        file system instance, not necessarily of this particular class.
+
+        Warnings
+        --------
+        This can import arbitrary modules (as determined by the ``cls`` key).
+        Make sure you haven't installed any modules that may execute malicious code
+        at import time.
+        """
+        from .json import FilesystemJSONDecoder
+
+        json_decoder = FilesystemJSONDecoder()
+
+        dct = dict(dct)  # Defensive copy
+
+        cls = FilesystemJSONDecoder.try_resolve_fs_cls(dct)
+        if cls is None:
+            raise ValueError("Not a serialized AbstractFileSystem")
+
+        dct.pop("cls", None)
+        dct.pop("protocol", None)
+
+        return cls(
+            *json_decoder.unmake_serializable(dct.pop("args", ())),
+            **json_decoder.unmake_serializable(dct),
+        )
+
+    def _get_pyarrow_filesystem(self):
+        """
+        Make a version of the FS instance which will be acceptable to pyarrow
+        """
+        # all instances already also derive from pyarrow
+        return self
+
+    def get_mapper(self, root="", check=False, create=False, missing_exceptions=None):
+        """Create key/value store based on this file-system
+
+        Makes a MutableMapping interface to the FS at the given root path.
+        See ``fsspec.mapping.FSMap`` for further details.
+        """
+        from .mapping import FSMap
+
+        return FSMap(
+            root,
+            self,
+            check=check,
+            create=create,
+            missing_exceptions=missing_exceptions,
+        )
+
+    @classmethod
+    def clear_instance_cache(cls):
+        """
+        Clear the cache of filesystem instances.
+
+        Notes
+        -----
+        Unless overridden by setting the ``cachable`` class attribute to False,
+        the filesystem class stores a reference to newly created instances. This
+        prevents Python's normal rules around garbage collection from working,
+        since the instances refcount will not drop to zero until
+        ``clear_instance_cache`` is called.
+        """
+        cls._cache.clear()
+
+    def created(self, path):
+        """Return the created timestamp of a file as a datetime.datetime"""
+        raise NotImplementedError
+
+    def modified(self, path):
+        """Return the modified timestamp of a file as a datetime.datetime"""
+        raise NotImplementedError
+
+    def tree(
+        self,
+        path: str = "/",
+        recursion_limit: int = 2,
+        max_display: int = 25,
+        display_size: bool = False,
+        prefix: str = "",
+        is_last: bool = True,
+        first: bool = True,
+        indent_size: int = 4,
+    ) -> str:
+        """
+        Return a tree-like structure of the filesystem starting from the given path as a string.
+
+        Parameters
+        ----------
+            path: Root path to start traversal from
+            recursion_limit: Maximum depth of directory traversal
+            max_display: Maximum number of items to display per directory
+            display_size: Whether to display file sizes
+            prefix: Current line prefix for visual tree structure
+            is_last: Whether current item is last in its level
+            first: Whether this is the first call (displays root path)
+            indent_size: Number of spaces by indent
+
+        Returns
+        -------
+            str: A string representing the tree structure.
+
+        Example
+        -------
+            >>> from fsspec import filesystem
+
+            >>> fs = filesystem('ftp', host='test.rebex.net', user='demo', password='password')
+            >>> tree = fs.tree(display_size=True, recursion_limit=3, indent_size=8, max_display=10)
+            >>> print(tree)
+        """
+
+        def format_bytes(n: int) -> str:
+            """Format bytes as text."""
+            for prefix, k in (
+                ("P", 2**50),
+                ("T", 2**40),
+                ("G", 2**30),
+                ("M", 2**20),
+                ("k", 2**10),
+            ):
+                if n >= 0.9 * k:
+                    return f"{n / k:.2f} {prefix}b"
+            return f"{n}B"
+
+        result = []
+
+        if first:
+            result.append(path)
+
+        if recursion_limit:
+            indent = " " * indent_size
+            contents = self.ls(path, detail=True)
+            contents.sort(
+                key=lambda x: (x.get("type") != "directory", x.get("name", ""))
+            )
+
+            if max_display is not None and len(contents) > max_display:
+                displayed_contents = contents[:max_display]
+                remaining_count = len(contents) - max_display
+            else:
+                displayed_contents = contents
+                remaining_count = 0
+
+            for i, item in enumerate(displayed_contents):
+                is_last_item = (i == len(displayed_contents) - 1) and (
+                    remaining_count == 0
+                )
+
+                branch = (
+                    "└" + ("─" * (indent_size - 2))
+                    if is_last_item
+                    else "├" + ("─" * (indent_size - 2))
+                )
+                branch += " "
+                new_prefix = prefix + (
+                    indent if is_last_item else "│" + " " * (indent_size - 1)
+                )
+
+                name = os.path.basename(item.get("name", ""))
+
+                if display_size and item.get("type") == "directory":
+                    sub_contents = self.ls(item.get("name", ""), detail=True)
+                    num_files = sum(
+                        1 for sub_item in sub_contents if sub_item.get("type") == "file"
+                    )
+                    num_folders = sum(
+                        1
+                        for sub_item in sub_contents
+                        if sub_item.get("type") == "directory"
+                    )
+
+                    if num_files == 0 and num_folders == 0:
+                        size = " (empty folder)"
+                    elif num_files == 0:
+                        size = f" ({num_folders} subfolder{'s' if num_folders > 1 else ''})"
+                    elif num_folders == 0:
+                        size = f" ({num_files} file{'s' if num_files > 1 else ''})"
+                    else:
+                        size = f" ({num_files} file{'s' if num_files > 1 else ''}, {num_folders} subfolder{'s' if num_folders > 1 else ''})"
+                elif display_size and item.get("type") == "file":
+                    size = f" ({format_bytes(item.get('size', 0))})"
+                else:
+                    size = ""
+
+                result.append(f"{prefix}{branch}{name}{size}")
+
+                if item.get("type") == "directory" and recursion_limit > 0:
+                    result.append(
+                        self.tree(
+                            path=item.get("name", ""),
+                            recursion_limit=recursion_limit - 1,
+                            max_display=max_display,
+                            display_size=display_size,
+                            prefix=new_prefix,
+                            is_last=is_last_item,
+                            first=False,
+                            indent_size=indent_size,
+                        )
+                    )
+
+            if remaining_count > 0:
+                more_message = f"{remaining_count} more item(s) not displayed."
+                result.append(
+                    f"{prefix}{'└' + ('─' * (indent_size - 2))} {more_message}"
+                )
+
+        return "\n".join(_ for _ in result if _)
+
+    # ------------------------------------------------------------------------
+    # Aliases
+
+    def read_bytes(self, path, start=None, end=None, **kwargs):
+        """Alias of `AbstractFileSystem.cat_file`."""
+        return self.cat_file(path, start=start, end=end, **kwargs)
+
+    def write_bytes(self, path, value, **kwargs):
+        """Alias of `AbstractFileSystem.pipe_file`."""
+        self.pipe_file(path, value, **kwargs)
+
+    def makedir(self, path, create_parents=True, **kwargs):
+        """Alias of `AbstractFileSystem.mkdir`."""
+        return self.mkdir(path, create_parents=create_parents, **kwargs)
+
+    def mkdirs(self, path, exist_ok=False):
+        """Alias of `AbstractFileSystem.makedirs`."""
+        return self.makedirs(path, exist_ok=exist_ok)
+
+    def listdir(self, path, detail=True, **kwargs):
+        """Alias of `AbstractFileSystem.ls`."""
+        return self.ls(path, detail=detail, **kwargs)
+
+    def cp(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.copy`."""
+        return self.copy(path1, path2, **kwargs)
+
+    def move(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.mv`."""
+        return self.mv(path1, path2, **kwargs)
+
+    def stat(self, path, **kwargs):
+        """Alias of `AbstractFileSystem.info`."""
+        return self.info(path, **kwargs)
+
+    def disk_usage(self, path, total=True, maxdepth=None, **kwargs):
+        """Alias of `AbstractFileSystem.du`."""
+        return self.du(path, total=total, maxdepth=maxdepth, **kwargs)
+
+    def rename(self, path1, path2, **kwargs):
+        """Alias of `AbstractFileSystem.mv`."""
+        return self.mv(path1, path2, **kwargs)
+
+    def delete(self, path, recursive=False, maxdepth=None):
+        """Alias of `AbstractFileSystem.rm`."""
+        return self.rm(path, recursive=recursive, maxdepth=maxdepth)
+
+    def upload(self, lpath, rpath, recursive=False, **kwargs):
+        """Alias of `AbstractFileSystem.put`."""
+        return self.put(lpath, rpath, recursive=recursive, **kwargs)
+
+    def download(self, rpath, lpath, recursive=False, **kwargs):
+        """Alias of `AbstractFileSystem.get`."""
+        return self.get(rpath, lpath, recursive=recursive, **kwargs)
+
+    def sign(self, path, expiration=100, **kwargs):
+        """Create a signed URL representing the given path
+
+        Some implementations allow temporary URLs to be generated, as a
+        way of delegating credentials.
+
+        Parameters
+        ----------
+        path : str
+             The path on the filesystem
+        expiration : int
+            Number of seconds to enable the URL for (if supported)
+
+        Returns
+        -------
+        URL : str
+            The signed URL
+
+        Raises
+        ------
+        NotImplementedError : if method is not implemented for a filesystem
+        """
+        raise NotImplementedError("Sign is not implemented for this filesystem")
+
+    def _isfilestore(self):
+        # Originally inherited from pyarrow DaskFileSystem. Keeping this
+        # here for backwards compatibility as long as pyarrow uses its
+        # legacy fsspec-compatible filesystems and thus accepts fsspec
+        # filesystems as well
+        return False
+
+
+class AbstractBufferedFile(io.IOBase):
+    """Convenient class to derive from to provide buffering
+
+    In the case that the backend does not provide a pythonic file-like object
+    already, this class contains much of the logic to build one. The only
+    methods that need to be overridden are ``_upload_chunk``,
+    ``_initiate_upload`` and ``_fetch_range``.
+    """
+
+    DEFAULT_BLOCK_SIZE = 5 * 2**20
+    _details = None
+
+    def __init__(
+        self,
+        fs,
+        path,
+        mode="rb",
+        block_size="default",
+        autocommit=True,
+        cache_type="readahead",
+        cache_options=None,
+        size=None,
+        **kwargs,
+    ):
+        """
+        Template for files with buffered reading and writing
+
+        Parameters
+        ----------
+        fs: instance of FileSystem
+        path: str
+            location in file-system
+        mode: str
+            Normal file modes. Currently only 'wb', 'ab' or 'rb'. Some file
+            systems may be read-only, and some may not support append.
+        block_size: int
+            Buffer size for reading or writing, 'default' for class default
+        autocommit: bool
+            Whether to write to final destination; may only impact what
+            happens when file is being closed.
+        cache_type: {"readahead", "none", "mmap", "bytes"}, default "readahead"
+            Caching policy in read mode. See the definitions in ``core``.
+        cache_options : dict
+            Additional options passed to the constructor for the cache specified
+            by `cache_type`.
+        size: int
+            If given and in read mode, suppressed having to look up the file size
+        kwargs:
+            Gets stored as self.kwargs
+        """
+        from .core import caches
+
+        self.path = path
+        self.fs = fs
+        self.mode = mode
+        self.blocksize = (
+            self.DEFAULT_BLOCK_SIZE if block_size in ["default", None] else block_size
+        )
+        self.loc = 0
+        self.autocommit = autocommit
+        self.end = None
+        self.start = None
+        self.closed = False
+
+        if cache_options is None:
+            cache_options = {}
+
+        if "trim" in kwargs:
+            warnings.warn(
+                "Passing 'trim' to control the cache behavior has been deprecated. "
+                "Specify it within the 'cache_options' argument instead.",
+                FutureWarning,
+            )
+            cache_options["trim"] = kwargs.pop("trim")
+
+        self.kwargs = kwargs
+
+        if mode not in {"ab", "rb", "wb", "xb"}:
+            raise NotImplementedError("File mode not supported")
+        if mode == "rb":
+            if size is not None:
+                self.size = size
+            else:
+                self.size = self.details["size"]
+            self.cache = caches[cache_type](
+                self.blocksize, self._fetch_range, self.size, **cache_options
+            )
+        else:
+            self.buffer = io.BytesIO()
+            self.offset = None
+            self.forced = False
+            self.location = None
+
+    @property
+    def details(self):
+        if self._details is None:
+            self._details = self.fs.info(self.path)
+        return self._details
+
+    @details.setter
+    def details(self, value):
+        self._details = value
+        self.size = value["size"]
+
+    @property
+    def full_name(self):
+        return _unstrip_protocol(self.path, self.fs)
+
+    @property
+    def closed(self):
+        # get around this attr being read-only in IOBase
+        # use getattr here, since this can be called during del
+        return getattr(self, "_closed", True)
+
+    @closed.setter
+    def closed(self, c):
+        self._closed = c
+
+    def __hash__(self):
+        if "w" in self.mode:
+            return id(self)
+        else:
+            return int(tokenize(self.details), 16)
+
+    def __eq__(self, other):
+        """Files are equal if they have the same checksum, only in read mode"""
+        if self is other:
+            return True
+        return (
+            isinstance(other, type(self))
+            and self.mode == "rb"
+            and other.mode == "rb"
+            and hash(self) == hash(other)
+        )
+
+    def commit(self):
+        """Move from temp to final destination"""
+
+    def discard(self):
+        """Throw away temporary file"""
+
+    def info(self):
+        """File information about this path"""
+        if self.readable():
+            return self.details
+        else:
+            raise ValueError("Info not available while writing")
+
+    def tell(self):
+        """Current file location"""
+        return self.loc
+
+    def seek(self, loc, whence=0):
+        """Set current file location
+
+        Parameters
+        ----------
+        loc: int
+            byte location
+        whence: {0, 1, 2}
+            from start of file, current location or end of file, resp.
+        """
+        loc = int(loc)
+        if not self.mode == "rb":
+            raise OSError(ESPIPE, "Seek only available in read mode")
+        if whence == 0:
+            nloc = loc
+        elif whence == 1:
+            nloc = self.loc + loc
+        elif whence == 2:
+            nloc = self.size + loc
+        else:
+            raise ValueError(f"invalid whence ({whence}, should be 0, 1 or 2)")
+        if nloc < 0:
+            raise ValueError("Seek before start of file")
+        self.loc = nloc
+        return self.loc
+
+    def write(self, data):
+        """
+        Write data to buffer.
+
+        Buffer only sent on flush() or if buffer is greater than
+        or equal to blocksize.
+
+        Parameters
+        ----------
+        data: bytes
+            Set of bytes to be written.
+        """
+        if not self.writable():
+            raise ValueError("File not in write mode")
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if self.forced:
+            raise ValueError("This file has been force-flushed, can only close")
+        out = self.buffer.write(data)
+        self.loc += out
+        if self.buffer.tell() >= self.blocksize:
+            self.flush()
+        return out
+
+    def flush(self, force=False):
+        """
+        Write buffered data to backend store.
+
+        Writes the current buffer, if it is larger than the block-size, or if
+        the file is being closed.
+
+        Parameters
+        ----------
+        force: bool
+            When closing, write the last block even if it is smaller than
+            blocks are allowed to be. Disallows further writing to this file.
+        """
+
+        if self.closed:
+            raise ValueError("Flush on closed file")
+        if force and self.forced:
+            raise ValueError("Force flush cannot be called more than once")
+        if force:
+            self.forced = True
+
+        if self.readable():
+            # no-op to flush on read-mode
+            return
+
+        if not force and self.buffer.tell() < self.blocksize:
+            # Defer write on small block
+            return
+
+        if self.offset is None:
+            # Initialize a multipart upload
+            self.offset = 0
+            try:
+                self._initiate_upload()
+            except Exception:
+                self.closed = True
+                raise
+
+        if self._upload_chunk(final=force) is not False:
+            self.offset += self.buffer.seek(0, 2)
+            self.buffer = io.BytesIO()
+
+    def _upload_chunk(self, final=False):
+        """Write one part of a multi-block file upload
+
+        Parameters
+        ==========
+        final: bool
+            This is the last block, so should complete file, if
+            self.autocommit is True.
+        """
+        # may not yet have been initialized, may need to call _initialize_upload
+
+    def _initiate_upload(self):
+        """Create remote file/upload"""
+        pass
+
+    def _fetch_range(self, start, end):
+        """Get the specified set of bytes from remote"""
+        return self.fs.cat_file(self.path, start=start, end=end)
+
+    def read(self, length=-1):
+        """
+        Return data from cache, or fetch pieces as necessary
+
+        Parameters
+        ----------
+        length: int (-1)
+            Number of bytes to read; if <0, all remaining bytes.
+        """
+        length = -1 if length is None else int(length)
+        if self.mode != "rb":
+            raise ValueError("File not in read mode")
+        if length < 0:
+            length = self.size - self.loc
+        if self.closed:
+            raise ValueError("I/O operation on closed file.")
+        if length == 0:
+            # don't even bother calling fetch
+            return b""
+        out = self.cache._fetch(self.loc, self.loc + length)
+
+        logger.debug(
+            "%s read: %i - %i %s",
+            self,
+            self.loc,
+            self.loc + length,
+            self.cache._log_stats(),
+        )
+        self.loc += len(out)
+        return out
+
+    def readinto(self, b):
+        """mirrors builtin file's readinto method
+
+        https://docs.python.org/3/library/io.html#io.RawIOBase.readinto
+        """
+        out = memoryview(b).cast("B")
+        data = self.read(out.nbytes)
+        out[: len(data)] = data
+        return len(data)
+
+    def readuntil(self, char=b"\n", blocks=None):
+        """Return data between current position and first occurrence of char
+
+        char is included in the output, except if the end of the tile is
+        encountered first.
+
+        Parameters
+        ----------
+        char: bytes
+            Thing to find
+        blocks: None or int
+            How much to read in each go. Defaults to file blocksize - which may
+            mean a new read on every call.
+        """
+        out = []
+        while True:
+            start = self.tell()
+            part = self.read(blocks or self.blocksize)
+            if len(part) == 0:
+                break
+            found = part.find(char)
+            if found > -1:
+                out.append(part[: found + len(char)])
+                self.seek(start + found + len(char))
+                break
+            out.append(part)
+        return b"".join(out)
+
+    def readline(self):
+        """Read until and including the first occurrence of newline character
+
+        Note that, because of character encoding, this is not necessarily a
+        true line ending.
+        """
+        return self.readuntil(b"\n")
+
+    def __next__(self):
+        out = self.readline()
+        if out:
+            return out
+        raise StopIteration
+
+    def __iter__(self):
+        return self
+
+    def readlines(self):
+        """Return all data, split by the newline character, including the newline character"""
+        data = self.read()
+        lines = data.split(b"\n")
+        out = [l + b"\n" for l in lines[:-1]]
+        if data.endswith(b"\n"):
+            return out
+        else:
+            return out + [lines[-1]]
+        # return list(self)  ???
+
+    def readinto1(self, b):
+        return self.readinto(b)
+
+    def close(self):
+        """Close file
+
+        Finalizes writes, discards cache
+        """
+        if getattr(self, "_unclosable", False):
+            return
+        if self.closed:
+            return
+        try:
+            if self.mode == "rb":
+                cache = getattr(self, "cache", None)
+                if cache is not None:
+                    close = getattr(cache, "close", None)
+                    if callable(close):
+                        close()
+                self.cache = None
+            else:
+                if not getattr(self, "forced", True):
+                    self.flush(force=True)
+
+                if self.fs is not None:
+                    self.fs.invalidate_cache(self.path)
+                    self.fs.invalidate_cache(self.fs._parent(self.path))
+        finally:
+            self.closed = True
+
+    def readable(self):
+        """Whether opened for reading"""
+        return "r" in self.mode and not self.closed
+
+    def seekable(self):
+        """Whether is seekable (only in read mode)"""
+        return self.readable()
+
+    def writable(self):
+        """Whether opened for writing"""
+        return self.mode in {"wb", "ab", "xb"} and not self.closed
+
+    def __reduce__(self):
+        if self.mode != "rb":
+            raise RuntimeError("Pickling a writeable file is not supported")
+
+        return reopen, (
+            self.fs,
+            self.path,
+            self.mode,
+            self.blocksize,
+            self.loc,
+            self.size,
+            self.autocommit,
+            self.cache.name if self.cache else "none",
+            self.kwargs,
+        )
+
+    def __del__(self):
+        if not self.closed:
+            self.close()
+
+    def __str__(self):
+        return f"<File-like object {type(self.fs).__name__}, {self.path}>"
+
+    __repr__ = __str__
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.close()
+
+
+def reopen(fs, path, mode, blocksize, loc, size, autocommit, cache_type, kwargs):
+    file = fs.open(
+        path,
+        mode=mode,
+        block_size=blocksize,
+        autocommit=autocommit,
+        cache_type=cache_type,
+        size=size,
+        **kwargs,
+    )
+    if loc > 0:
+        file.seek(loc)
+    return file
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f5414dfd4239b27fd9a7c3946cf82d889d45106e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__init__.py
@@ -0,0 +1,290 @@
+import os
+from hashlib import md5
+
+import pytest
+
+from fsspec.implementations.local import LocalFileSystem
+from fsspec.tests.abstract.copy import AbstractCopyTests  # noqa: F401
+from fsspec.tests.abstract.get import AbstractGetTests  # noqa: F401
+from fsspec.tests.abstract.open import AbstractOpenTests  # noqa: F401
+from fsspec.tests.abstract.pipe import AbstractPipeTests  # noqa: F401
+from fsspec.tests.abstract.put import AbstractPutTests  # noqa: F401
+
+
+class BaseAbstractFixtures:
+    """
+    Abstract base class containing fixtures that are used by but never need to
+    be overridden in derived filesystem-specific classes to run the abstract
+    tests on such filesystems.
+    """
+
+    @pytest.fixture
+    def fs_bulk_operations_scenario_0(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used for many cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._bulk_operations_scenario_0(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_glob_edge_cases_files(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used for glob edge cases cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._glob_edge_cases_files(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_dir_and_file_with_same_name_prefix(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used to check cp/get/put on directory
+        and file with the same name prefixes.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._dir_and_file_with_same_name_prefix(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_10_files_with_hashed_names(self, fs, fs_join, fs_path):
+        """
+        Scenario on remote filesystem that is used to check cp/get/put files order
+        when source and destination are lists.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._10_files_with_hashed_names(fs, fs_join, fs_path)
+        yield source
+        fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def fs_target(self, fs, fs_join, fs_path):
+        """
+        Return name of remote directory that does not yet exist to copy into.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        target = fs_join(fs_path, "target")
+        yield target
+        if fs.exists(target):
+            fs.rm(target, recursive=True)
+
+    @pytest.fixture
+    def local_bulk_operations_scenario_0(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used for many cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._bulk_operations_scenario_0(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_glob_edge_cases_files(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used for glob edge cases cp/get/put tests.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._glob_edge_cases_files(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_dir_and_file_with_same_name_prefix(
+        self, local_fs, local_join, local_path
+    ):
+        """
+        Scenario on local filesystem that is used to check cp/get/put on directory
+        and file with the same name prefixes.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._dir_and_file_with_same_name_prefix(
+            local_fs, local_join, local_path
+        )
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_10_files_with_hashed_names(self, local_fs, local_join, local_path):
+        """
+        Scenario on local filesystem that is used to check cp/get/put files order
+        when source and destination are lists.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        source = self._10_files_with_hashed_names(local_fs, local_join, local_path)
+        yield source
+        local_fs.rm(source, recursive=True)
+
+    @pytest.fixture
+    def local_target(self, local_fs, local_join, local_path):
+        """
+        Return name of local directory that does not yet exist to copy into.
+
+        Cleans up at the end of each test it which it is used.
+        """
+        target = local_join(local_path, "target")
+        yield target
+        if local_fs.exists(target):
+            local_fs.rm(target, recursive=True)
+
+    def _glob_edge_cases_files(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used for glob edge cases cp/get/put tests.
+        Creates the following directory and file structure:
+
+        📁 source
+        ├── 📄 file1
+        ├── 📄 file2
+        ├── 📁 subdir0
+        │   ├── 📄 subfile1
+        │   ├── 📄 subfile2
+        │   └── 📁 nesteddir
+        │       └── 📄 nestedfile
+        └── 📁 subdir1
+            ├── 📄 subfile1
+            ├── 📄 subfile2
+            └── 📁 nesteddir
+                └── 📄 nestedfile
+        """
+        source = some_join(some_path, "source")
+        some_fs.touch(some_join(source, "file1"))
+        some_fs.touch(some_join(source, "file2"))
+
+        for subdir_idx in range(2):
+            subdir = some_join(source, f"subdir{subdir_idx}")
+            nesteddir = some_join(subdir, "nesteddir")
+            some_fs.makedirs(nesteddir)
+            some_fs.touch(some_join(subdir, "subfile1"))
+            some_fs.touch(some_join(subdir, "subfile2"))
+            some_fs.touch(some_join(nesteddir, "nestedfile"))
+
+        return source
+
+    def _bulk_operations_scenario_0(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used for many cp/get/put tests. Creates the following
+        directory and file structure:
+
+        📁 source
+        ├── 📄 file1
+        ├── 📄 file2
+        └── 📁 subdir
+            ├── 📄 subfile1
+            ├── 📄 subfile2
+            └── 📁 nesteddir
+                └── 📄 nestedfile
+        """
+        source = some_join(some_path, "source")
+        subdir = some_join(source, "subdir")
+        nesteddir = some_join(subdir, "nesteddir")
+        some_fs.makedirs(nesteddir)
+        some_fs.touch(some_join(source, "file1"))
+        some_fs.touch(some_join(source, "file2"))
+        some_fs.touch(some_join(subdir, "subfile1"))
+        some_fs.touch(some_join(subdir, "subfile2"))
+        some_fs.touch(some_join(nesteddir, "nestedfile"))
+        return source
+
+    def _dir_and_file_with_same_name_prefix(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used to check cp/get/put on directory and file with
+        the same name prefixes. Creates the following directory and file structure:
+
+        📁 source
+        ├── 📄 subdir.txt
+        └── 📁 subdir
+            └── 📄 subfile.txt
+        """
+        source = some_join(some_path, "source")
+        subdir = some_join(source, "subdir")
+        file = some_join(source, "subdir.txt")
+        subfile = some_join(subdir, "subfile.txt")
+        some_fs.makedirs(subdir)
+        some_fs.touch(file)
+        some_fs.touch(subfile)
+        return source
+
+    def _10_files_with_hashed_names(self, some_fs, some_join, some_path):
+        """
+        Scenario that is used to check cp/get/put files order when source and
+        destination are lists. Creates the following directory and file structure:
+
+        📁 source
+        └── 📄 {hashed([0-9])}.txt
+        """
+        source = some_join(some_path, "source")
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            path = some_join(source, f"{hashed_i}.txt")
+            some_fs.pipe(path=path, value=f"{i}".encode())
+        return source
+
+
+class AbstractFixtures(BaseAbstractFixtures):
+    """
+    Abstract base class containing fixtures that may be overridden in derived
+    filesystem-specific classes to run the abstract tests on such filesystems.
+
+    For any particular filesystem some of these fixtures must be overridden,
+    such as ``fs`` and ``fs_path``, and others may be overridden if the
+    default functions here are not appropriate, such as ``fs_join``.
+    """
+
+    @pytest.fixture
+    def fs(self):
+        raise NotImplementedError("This function must be overridden in derived classes")
+
+    @pytest.fixture
+    def fs_join(self):
+        """
+        Return a function that joins its arguments together into a path.
+
+        Most fsspec implementations join paths in a platform-dependent way,
+        but some will override this to always use a forward slash.
+        """
+        return os.path.join
+
+    @pytest.fixture
+    def fs_path(self):
+        raise NotImplementedError("This function must be overridden in derived classes")
+
+    @pytest.fixture(scope="class")
+    @classmethod
+    def local_fs(cls):
+        # Maybe need an option for auto_mkdir=False?  This is only relevant
+        # for certain implementations.
+        return LocalFileSystem(auto_mkdir=True)
+
+    @pytest.fixture
+    def local_join(self):
+        """
+        Return a function that joins its arguments together into a path, on
+        the local filesystem.
+        """
+        return os.path.join
+
+    @pytest.fixture
+    def local_path(self, tmpdir):
+        return tmpdir
+
+    @pytest.fixture
+    def supports_empty_directories(self):
+        """
+        Return whether this implementation supports empty directories.
+        """
+        return True
+
+    @pytest.fixture
+    def fs_sanitize_path(self):
+        return lambda x: x
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c110e7305bafd95a79365b18c51f532ab6738449
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2493401b4adb8193abb6663401b7626ffb21adb
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/common.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..550dacf2b153f22590ca1f59ddb89954bf0826ee
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/copy.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3f8a7d5ce13401b826f38754b0d196944a48da95
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/get.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/mv.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/mv.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dbcbba521f8ab09368c0d4cdd30e44b64945f507
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/mv.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/open.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/open.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc15313b8ef7d5bbdc6c3b460ceb62f8df2c7af3
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/open.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/pipe.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/pipe.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e7c1e025d8a4278ca7b510abc117a6535f4173a5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/pipe.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..39612edbe01d7695566ecb48281e69a576678739
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/__pycache__/put.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/common.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/common.py
new file mode 100644
index 0000000000000000000000000000000000000000..22e7c4140404ab2a8928689721419cf05c2760b9
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/common.py
@@ -0,0 +1,175 @@
+GLOB_EDGE_CASES_TESTS = {
+    "argnames": ("path", "recursive", "maxdepth", "expected"),
+    "argvalues": [
+        ("fil?1", False, None, ["file1"]),
+        ("fil?1", True, None, ["file1"]),
+        ("file[1-2]", False, None, ["file1", "file2"]),
+        ("file[1-2]", True, None, ["file1", "file2"]),
+        ("*", False, None, ["file1", "file2"]),
+        (
+            "*",
+            True,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("*", True, 1, ["file1", "file2"]),
+        (
+            "*",
+            True,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        ("*1", False, None, ["file1"]),
+        (
+            "*1",
+            True,
+            None,
+            [
+                "file1",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("*1", True, 2, ["file1", "subdir1/subfile1", "subdir1/subfile2"]),
+        (
+            "**",
+            False,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "**",
+            True,
+            None,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("**", True, 1, ["file1", "file2"]),
+        (
+            "**",
+            True,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "**",
+            False,
+            2,
+            [
+                "file1",
+                "file2",
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        ("**/*1", False, None, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        (
+            "**/*1",
+            True,
+            None,
+            [
+                "file1",
+                "subdir0/subfile1",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        ("**/*1", True, 1, ["file1"]),
+        (
+            "**/*1",
+            True,
+            2,
+            ["file1", "subdir0/subfile1", "subdir1/subfile1", "subdir1/subfile2"],
+        ),
+        ("**/*1", False, 2, ["file1", "subdir0/subfile1", "subdir1/subfile1"]),
+        ("**/subdir0", False, None, []),
+        ("**/subdir0", True, None, ["subfile1", "subfile2", "nesteddir/nestedfile"]),
+        ("**/subdir0/nested*", False, 2, []),
+        ("**/subdir0/nested*", True, 2, ["nestedfile"]),
+        ("subdir[1-2]", False, None, []),
+        ("subdir[1-2]", True, None, ["subfile1", "subfile2", "nesteddir/nestedfile"]),
+        ("subdir[1-2]", True, 2, ["subfile1", "subfile2"]),
+        ("subdir[0-1]", False, None, []),
+        (
+            "subdir[0-1]",
+            True,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir0/nesteddir/nestedfile",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+                "subdir1/nesteddir/nestedfile",
+            ],
+        ),
+        (
+            "subdir[0-1]/*fil[e]*",
+            False,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+        (
+            "subdir[0-1]/*fil[e]*",
+            True,
+            None,
+            [
+                "subdir0/subfile1",
+                "subdir0/subfile2",
+                "subdir1/subfile1",
+                "subdir1/subfile2",
+            ],
+        ),
+    ],
+}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py
new file mode 100644
index 0000000000000000000000000000000000000000..e39e57e5f7d52bfda8ab5e2398b04cc2303630a0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/copy.py
@@ -0,0 +1,557 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractCopyTests:
+    def test_copy_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1a
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        target_file2 = fs_join(target, "file2")
+        target_subfile1 = fs_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.cp(fs_join(source, "file2"), target)
+        assert fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.cp(fs_join(source, "subdir", "subfile1"), target)
+        assert fs.isfile(target_subfile1)
+
+        # Remove copied files
+        fs.rm([target_file2, target_subfile1])
+        assert not fs.exists(target_file2)
+        assert not fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.cp(fs_join(source, "file2"), target + "/")
+        assert fs.isdir(target)
+        assert fs.isfile(target_file2)
+
+        fs.cp(fs_join(source, "subdir", "subfile1"), target + "/")
+        assert fs.isfile(target_subfile1)
+
+    def test_copy_file_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1b
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.cp(
+            fs_join(source, "subdir", "subfile1"), fs_join(target, "newdir/")
+        )  # Note trailing slash
+        assert fs.isdir(target)
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_copy_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1c
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        fs.cp(fs_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
+        assert fs.isfile(fs_join(target, "newfile"))
+
+    def test_copy_file_to_file_in_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1d
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.cp(
+            fs_join(source, "subdir", "subfile1"), fs_join(target, "newdir", "newfile")
+        )
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "newfile"))
+
+    def test_copy_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1e
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.cp(s, t)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # With recursive
+            fs.cp(s, t, recursive=True)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "subdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # Limit recursive by maxdepth
+            fs.cp(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+    def test_copy_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1f
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.cp(s, t)
+            if supports_empty_directories:
+                assert fs.ls(target) == []
+            else:
+                with pytest.raises(FileNotFoundError):
+                    fs.ls(target)
+
+            # With recursive
+            fs.cp(s, t, recursive=True)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+            assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # Limit recursive by maxdepth
+            fs.cp(s, t, recursive=True, maxdepth=1)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+    def test_copy_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1g
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.cp(fs_join(source, "subdir", "*"), t)
+            assert fs.isfile(fs_join(target, "subfile1"))
+            assert fs.isfile(fs_join(target, "subfile2"))
+            assert not fs.isdir(fs_join(target, "nesteddir"))
+            assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(
+                [
+                    fs_join(target, "subfile1"),
+                    fs_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.cp(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
+
+                # Limit recursive by maxdepth
+                fs.cp(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
+
+    def test_copy_glob_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 1h
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.cp(fs_join(source, "subdir", "*"), t)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.cp(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.cp(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_copy_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_glob_edge_cases_files,
+        fs_target,
+        fs_sanitize_path,
+    ):
+        # Copy scenario 1g
+        source = fs_glob_edge_cases_files
+
+        target = fs_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            fs.mkdir(target)
+
+            t = fs_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.copy(fs_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_copy_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        fs_target,
+        supports_empty_directories,
+    ):
+        # Copy scenario 2a
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.cp(source_files, t)
+            assert fs.isfile(fs_join(target, "file1"))
+            assert fs.isfile(fs_join(target, "file2"))
+            assert fs.isfile(fs_join(target, "subfile1"))
+
+            fs.rm(
+                [
+                    fs_join(target, "file1"),
+                    fs_join(target, "file2"),
+                    fs_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+    def test_copy_list_of_files_to_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # Copy scenario 2b
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.cp(source_files, fs_join(target, "newdir") + "/")  # Note trailing slash
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "file1"))
+        assert fs.isfile(fs_join(target, "newdir", "file2"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_copy_two_files_new_directory(
+        self, fs, fs_join, fs_bulk_operations_scenario_0, fs_target
+    ):
+        # This is a duplicate of test_copy_list_of_files_to_new_directory and
+        # can eventually be removed.
+        source = fs_bulk_operations_scenario_0
+
+        target = fs_target
+        assert not fs.exists(target)
+        fs.cp([fs_join(source, "file1"), fs_join(source, "file2")], target)
+
+        assert fs.isdir(target)
+        assert fs.isfile(fs_join(target, "file1"))
+        assert fs.isfile(fs_join(target, "file2"))
+
+    def test_copy_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        fs_dir_and_file_with_same_name_prefix,
+        supports_empty_directories,
+    ):
+        # Create the test dirs
+        source = fs_dir_and_file_with_same_name_prefix
+        target = fs_target
+
+        # Test without glob
+        fs.cp(fs_join(source, "subdir"), target, recursive=True)
+
+        assert fs.isfile(fs_join(target, "subfile.txt"))
+        assert not fs.isfile(fs_join(target, "subdir.txt"))
+
+        fs.rm([fs_join(target, "subfile.txt")])
+        if supports_empty_directories:
+            assert fs.ls(target) == []
+        else:
+            assert not fs.exists(target)
+
+        # Test with glob
+        fs.cp(fs_join(source, "subdir*"), target, recursive=True)
+
+        assert fs.isdir(fs_join(target, "subdir"))
+        assert fs.isfile(fs_join(target, "subdir", "subfile.txt"))
+        assert fs.isfile(fs_join(target, "subdir.txt"))
+
+    def test_copy_with_source_and_destination_as_list(
+        self, fs, fs_target, fs_join, fs_10_files_with_hashed_names
+    ):
+        # Create the test dir
+        source = fs_10_files_with_hashed_names
+        target = fs_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(fs_join(source, f"{hashed_i}.txt"))
+            destination_files.append(fs_join(target, f"{hashed_i}.txt"))
+
+        # Copy and assert order was kept
+        fs.copy(path1=source_files, path2=destination_files)
+
+        for i in range(10):
+            file_content = fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/get.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/get.py
new file mode 100644
index 0000000000000000000000000000000000000000..851ab81ee581e74cac41c64c83ef0af75826d6b0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/get.py
@@ -0,0 +1,587 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.implementations.local import make_path_posix
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractGetTests:
+    def test_get_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1a
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+        assert local_fs.isdir(target)
+
+        target_file2 = local_join(target, "file2")
+        target_subfile1 = local_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.get(fs_join(source, "file2"), target)
+        assert local_fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.get(fs_join(source, "subdir", "subfile1"), target)
+        assert local_fs.isfile(target_subfile1)
+
+        # Remove copied files
+        local_fs.rm([target_file2, target_subfile1])
+        assert not local_fs.exists(target_file2)
+        assert not local_fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.get(fs_join(source, "file2"), target + "/")
+        assert local_fs.isdir(target)
+        assert local_fs.isfile(target_file2)
+
+        fs.get(fs_join(source, "subdir", "subfile1"), target + "/")
+        assert local_fs.isfile(target_subfile1)
+
+    def test_get_file_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1b
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(
+            fs_join(source, "subdir", "subfile1"), local_join(target, "newdir/")
+        )  # Note trailing slash
+
+        assert local_fs.isdir(target)
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+
+    def test_get_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1c
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(fs_join(source, "subdir", "subfile1"), local_join(target, "newfile"))
+        assert local_fs.isfile(local_join(target, "newfile"))
+
+    def test_get_file_to_file_in_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1d
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        fs.get(
+            fs_join(source, "subdir", "subfile1"),
+            local_join(target, "newdir", "newfile"),
+        )
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "newfile"))
+
+    def test_get_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1e
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+        assert local_fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.get(s, t)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            fs.get(s, t, recursive=True)
+            if source_slash:
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert local_fs.isdir(local_join(target, "nesteddir"))
+                assert local_fs.isfile(local_join(target, "nesteddir", "nestedfile"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                        local_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert local_fs.isdir(local_join(target, "subdir"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile2"))
+                assert local_fs.isdir(local_join(target, "subdir", "nesteddir"))
+                assert local_fs.isfile(
+                    local_join(target, "subdir", "nesteddir", "nestedfile")
+                )
+
+                local_fs.rm(local_join(target, "subdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # Limit recursive by maxdepth
+            fs.get(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert not local_fs.exists(local_join(target, "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert local_fs.isdir(local_join(target, "subdir"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "subdir", "subfile2"))
+                assert not local_fs.exists(local_join(target, "subdir", "nesteddir"))
+
+                local_fs.rm(local_join(target, "subdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+    def test_get_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1f
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = local_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.get(s, t)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            fs.get(s, t, recursive=True)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
+            assert local_fs.isfile(
+                local_join(target, "newdir", "nesteddir", "nestedfile")
+            )
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # Limit recursive by maxdepth
+            fs.get(s, t, recursive=True, maxdepth=1)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert not local_fs.exists(local_join(target, "newdir"))
+
+    def test_get_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1g
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.get(fs_join(source, "subdir", "*"), t)
+            assert local_fs.isfile(local_join(target, "subfile1"))
+            assert local_fs.isfile(local_join(target, "subfile2"))
+            assert not local_fs.isdir(local_join(target, "nesteddir"))
+            assert not local_fs.exists(local_join(target, "nesteddir", "nestedfile"))
+            assert not local_fs.exists(local_join(target, "subdir"))
+
+            local_fs.rm(
+                [
+                    local_join(target, "subfile1"),
+                    local_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.get(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert local_fs.isdir(local_join(target, "nesteddir"))
+                assert local_fs.isfile(local_join(target, "nesteddir", "nestedfile"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                        local_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert local_fs.ls(target) == []
+
+                # Limit recursive by maxdepth
+                fs.get(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert local_fs.isfile(local_join(target, "subfile1"))
+                assert local_fs.isfile(local_join(target, "subfile2"))
+                assert not local_fs.exists(local_join(target, "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+
+                local_fs.rm(
+                    [
+                        local_join(target, "subfile1"),
+                        local_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert local_fs.ls(target) == []
+
+    def test_get_glob_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1h
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.get(fs_join(source, "subdir", "*"), t)
+            assert local_fs.isdir(local_join(target, "newdir"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+            assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+            assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+            assert not local_fs.exists(
+                local_join(target, "newdir", "nesteddir", "nestedfile")
+            )
+            assert not local_fs.exists(local_join(target, "subdir"))
+            assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+            local_fs.rm(local_join(target, "newdir"), recursive=True)
+            assert local_fs.ls(target) == []
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.get(fs_join(source, "subdir", glob), t, recursive=recursive)
+                assert local_fs.isdir(local_join(target, "newdir"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+                assert local_fs.isdir(local_join(target, "newdir", "nesteddir"))
+                assert local_fs.isfile(
+                    local_join(target, "newdir", "nesteddir", "nestedfile")
+                )
+                assert not local_fs.exists(local_join(target, "subdir"))
+                assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+                local_fs.rm(local_join(target, "newdir"), recursive=True)
+                assert not local_fs.exists(local_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.get(
+                    fs_join(source, "subdir", glob), t, recursive=recursive, maxdepth=1
+                )
+                assert local_fs.isdir(local_join(target, "newdir"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+                assert local_fs.isfile(local_join(target, "newdir", "subfile2"))
+                assert not local_fs.exists(local_join(target, "newdir", "nesteddir"))
+                assert not local_fs.exists(local_join(target, "subdir"))
+                assert not local_fs.exists(local_join(target, "newdir", "subdir"))
+
+                local_fs.rm(local_fs.ls(target, detail=False), recursive=True)
+                assert not local_fs.exists(local_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_get_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_glob_edge_cases_files,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 1g
+        source = fs_glob_edge_cases_files
+
+        target = local_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            local_fs.mkdir(target)
+
+            t = local_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.get(fs_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = local_fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    make_path_posix(local_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    make_path_posix(local_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                local_fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_get_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 2a
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.get(source_files, t)
+            assert local_fs.isfile(local_join(target, "file1"))
+            assert local_fs.isfile(local_join(target, "file2"))
+            assert local_fs.isfile(local_join(target, "subfile1"))
+
+            local_fs.rm(
+                [
+                    local_join(target, "file1"),
+                    local_join(target, "file2"),
+                    local_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert local_fs.ls(target) == []
+
+    def test_get_list_of_files_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_bulk_operations_scenario_0,
+        local_fs,
+        local_join,
+        local_target,
+    ):
+        # Copy scenario 2b
+        source = fs_bulk_operations_scenario_0
+
+        target = local_target
+        local_fs.mkdir(target)
+
+        source_files = [
+            fs_join(source, "file1"),
+            fs_join(source, "file2"),
+            fs_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.get(source_files, local_join(target, "newdir") + "/")  # Note trailing slash
+        assert local_fs.isdir(local_join(target, "newdir"))
+        assert local_fs.isfile(local_join(target, "newdir", "file1"))
+        assert local_fs.isfile(local_join(target, "newdir", "file2"))
+        assert local_fs.isfile(local_join(target, "newdir", "subfile1"))
+
+    def test_get_directory_recursive(
+        self, fs, fs_join, fs_path, local_fs, local_join, local_target
+    ):
+        # https://github.com/fsspec/filesystem_spec/issues/1062
+        # Recursive cp/get/put of source directory into non-existent target directory.
+        src = fs_join(fs_path, "src")
+        src_file = fs_join(src, "file")
+        fs.mkdir(src)
+        fs.touch(src_file)
+
+        target = local_target
+
+        # get without slash
+        assert not local_fs.exists(target)
+        for loop in range(2):
+            fs.get(src, target, recursive=True)
+            assert local_fs.isdir(target)
+
+            if loop == 0:
+                assert local_fs.isfile(local_join(target, "file"))
+                assert not local_fs.exists(local_join(target, "src"))
+            else:
+                assert local_fs.isfile(local_join(target, "file"))
+                assert local_fs.isdir(local_join(target, "src"))
+                assert local_fs.isfile(local_join(target, "src", "file"))
+
+        local_fs.rm(target, recursive=True)
+
+        # get with slash
+        assert not local_fs.exists(target)
+        for loop in range(2):
+            fs.get(src + "/", target, recursive=True)
+            assert local_fs.isdir(target)
+            assert local_fs.isfile(local_join(target, "file"))
+            assert not local_fs.exists(local_join(target, "src"))
+
+    def test_get_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        local_fs,
+        local_join,
+        local_target,
+        fs_dir_and_file_with_same_name_prefix,
+    ):
+        # Create the test dirs
+        source = fs_dir_and_file_with_same_name_prefix
+        target = local_target
+
+        # Test without glob
+        fs.get(fs_join(source, "subdir"), target, recursive=True)
+
+        assert local_fs.isfile(local_join(target, "subfile.txt"))
+        assert not local_fs.isfile(local_join(target, "subdir.txt"))
+
+        local_fs.rm([local_join(target, "subfile.txt")])
+        assert local_fs.ls(target) == []
+
+        # Test with glob
+        fs.get(fs_join(source, "subdir*"), target, recursive=True)
+
+        assert local_fs.isdir(local_join(target, "subdir"))
+        assert local_fs.isfile(local_join(target, "subdir", "subfile.txt"))
+        assert local_fs.isfile(local_join(target, "subdir.txt"))
+
+    def test_get_with_source_and_destination_as_list(
+        self,
+        fs,
+        fs_join,
+        local_fs,
+        local_join,
+        local_target,
+        fs_10_files_with_hashed_names,
+    ):
+        # Create the test dir
+        source = fs_10_files_with_hashed_names
+        target = local_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(fs_join(source, f"{hashed_i}.txt"))
+            destination_files.append(
+                make_path_posix(local_join(target, f"{hashed_i}.txt"))
+            )
+
+        # Copy and assert order was kept
+        fs.get(rpath=source_files, lpath=destination_files)
+
+        for i in range(10):
+            file_content = local_fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/mv.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/mv.py
new file mode 100644
index 0000000000000000000000000000000000000000..39f6caa3de815e024fa84de2acecc986c823ed29
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/mv.py
@@ -0,0 +1,57 @@
+import os
+
+import pytest
+
+import fsspec
+
+
+def test_move_raises_error_with_tmpdir(tmpdir):
+    # Create a file in the temporary directory
+    source = tmpdir.join("source_file.txt")
+    source.write("content")
+
+    # Define a destination that simulates a protected or invalid path
+    destination = tmpdir.join("non_existent_directory/destination_file.txt")
+
+    # Instantiate the filesystem (assuming the local file system interface)
+    fs = fsspec.filesystem("file")
+
+    # Use the actual file paths as string
+    with pytest.raises(FileNotFoundError):
+        fs.mv(str(source), str(destination))
+
+
+@pytest.mark.parametrize("recursive", (True, False))
+def test_move_raises_error_with_tmpdir_permission(recursive, tmpdir):
+    # Create a file in the temporary directory
+    source = tmpdir.join("source_file.txt")
+    source.write("content")
+
+    # Create a protected directory (non-writable)
+    protected_dir = tmpdir.mkdir("protected_directory")
+    protected_path = str(protected_dir)
+
+    # Set the directory to read-only
+    if os.name == "nt":
+        os.system(f'icacls "{protected_path}" /deny Everyone:(W)')
+    else:
+        os.chmod(protected_path, 0o555)  # Sets the directory to read-only
+
+    # Define a destination inside the protected directory
+    destination = protected_dir.join("destination_file.txt")
+
+    # Instantiate the filesystem (assuming the local file system interface)
+    fs = fsspec.filesystem("file")
+
+    # Try to move the file to the read-only directory, expecting a permission error
+    with pytest.raises(PermissionError):
+        fs.mv(str(source), str(destination), recursive=recursive)
+
+    # Assert the file was not created in the destination
+    assert not os.path.exists(destination)
+
+    # Cleanup: Restore permissions so the directory can be cleaned up
+    if os.name == "nt":
+        os.system(f'icacls "{protected_path}" /remove:d Everyone')
+    else:
+        os.chmod(protected_path, 0o755)  # Restore write permission for cleanup
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/open.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/open.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb75ea852276fb8d834345883813b8e27a0ae24c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/open.py
@@ -0,0 +1,11 @@
+import pytest
+
+
+class AbstractOpenTests:
+    def test_open_exclusive(self, fs, fs_target):
+        with fs.open(fs_target, "wb") as f:
+            f.write(b"data")
+        with fs.open(fs_target, "rb") as f:
+            assert f.read() == b"data"
+        with pytest.raises(FileExistsError):
+            fs.open(fs_target, "xb")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/pipe.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/pipe.py
new file mode 100644
index 0000000000000000000000000000000000000000..8ecca96e9d23ff268a253c48269d5cca451ea270
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/pipe.py
@@ -0,0 +1,11 @@
+import pytest
+
+
+class AbstractPipeTests:
+    def test_pipe_exclusive(self, fs, fs_target):
+        fs.pipe_file(fs_target, b"data")
+        assert fs.cat_file(fs_target) == b"data"
+        with pytest.raises(FileExistsError):
+            fs.pipe_file(fs_target, b"data", mode="create")
+        fs.pipe_file(fs_target, b"new data", mode="overwrite")
+        assert fs.cat_file(fs_target) == b"new data"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/put.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
new file mode 100644
index 0000000000000000000000000000000000000000..9fc349977f0384d9fc86126498be5c6ad99a21d3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/tests/abstract/put.py
@@ -0,0 +1,591 @@
+from hashlib import md5
+from itertools import product
+
+import pytest
+
+from fsspec.tests.abstract.common import GLOB_EDGE_CASES_TESTS
+
+
+class AbstractPutTests:
+    def test_put_file_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1a
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        target_file2 = fs_join(target, "file2")
+        target_subfile1 = fs_join(target, "subfile1")
+
+        # Copy from source directory
+        fs.put(local_join(source, "file2"), target)
+        assert fs.isfile(target_file2)
+
+        # Copy from sub directory
+        fs.put(local_join(source, "subdir", "subfile1"), target)
+        assert fs.isfile(target_subfile1)
+
+        # Remove copied files
+        fs.rm([target_file2, target_subfile1])
+        assert not fs.exists(target_file2)
+        assert not fs.exists(target_subfile1)
+
+        # Repeat with trailing slash on target
+        fs.put(local_join(source, "file2"), target + "/")
+        assert fs.isdir(target)
+        assert fs.isfile(target_file2)
+
+        fs.put(local_join(source, "subdir", "subfile1"), target + "/")
+        assert fs.isfile(target_subfile1)
+
+    def test_put_file_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1b
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.put(
+            local_join(source, "subdir", "subfile1"), fs_join(target, "newdir/")
+        )  # Note trailing slash
+        assert fs.isdir(target)
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_put_file_to_file_in_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
+    ):
+        # Copy scenario 1c
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            fs.touch(fs_join(target, "dummy"))
+        assert fs.isdir(target)
+
+        fs.put(local_join(source, "subdir", "subfile1"), fs_join(target, "newfile"))
+        assert fs.isfile(fs_join(target, "newfile"))
+
+    def test_put_file_to_file_in_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1d
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        fs.put(
+            local_join(source, "subdir", "subfile1"),
+            fs_join(target, "newdir", "newfile"),
+        )
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "newfile"))
+
+    def test_put_directory_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1e
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = target + "/" if target_slash else target
+
+            # Without recursive does nothing
+            fs.put(s, t)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # With recursive
+            fs.put(s, t, recursive=True)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "subdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "subdir", "nesteddir", "nestedfile"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # Limit recursive by maxdepth
+            fs.put(s, t, recursive=True, maxdepth=1)
+            if source_slash:
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+            else:
+                assert fs.isdir(fs_join(target, "subdir"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "subdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "subdir", "nesteddir"))
+
+                fs.rm(fs_join(target, "subdir"), recursive=True)
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+    def test_put_directory_to_new_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 1f
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for source_slash, target_slash in zip([False, True], [False, True]):
+            s = fs_join(source, "subdir")
+            if source_slash:
+                s += "/"
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive does nothing
+            fs.put(s, t)
+            if supports_empty_directories:
+                assert fs.ls(target) == []
+            else:
+                with pytest.raises(FileNotFoundError):
+                    fs.ls(target)
+
+            # With recursive
+            fs.put(s, t, recursive=True)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+            assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # Limit recursive by maxdepth
+            fs.put(s, t, recursive=True, maxdepth=1)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+    def test_put_glob_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        supports_empty_directories,
+        local_bulk_operations_scenario_0,
+    ):
+        # Copy scenario 1g
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            # Without recursive
+            fs.put(local_join(source, "subdir", "*"), t)
+            assert fs.isfile(fs_join(target, "subfile1"))
+            assert fs.isfile(fs_join(target, "subfile2"))
+            assert not fs.isdir(fs_join(target, "nesteddir"))
+            assert not fs.exists(fs_join(target, "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+
+            fs.rm(
+                [
+                    fs_join(target, "subfile1"),
+                    fs_join(target, "subfile2"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert fs.isdir(fs_join(target, "nesteddir"))
+                assert fs.isfile(fs_join(target, "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                        fs_join(target, "nesteddir"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isfile(fs_join(target, "subfile1"))
+                assert fs.isfile(fs_join(target, "subfile2"))
+                assert not fs.exists(fs_join(target, "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+
+                fs.rm(
+                    [
+                        fs_join(target, "subfile1"),
+                        fs_join(target, "subfile2"),
+                    ],
+                    recursive=True,
+                )
+                assert fs.ls(target, detail=False) == (
+                    [] if supports_empty_directories else [dummy]
+                )
+
+    def test_put_glob_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 1h
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        for target_slash in [False, True]:
+            t = fs_join(target, "newdir")
+            if target_slash:
+                t += "/"
+
+            # Without recursive
+            fs.put(local_join(source, "subdir", "*"), t)
+            assert fs.isdir(fs_join(target, "newdir"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+            assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+            assert not fs.exists(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+            assert not fs.exists(fs_join(target, "subdir"))
+            assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+            fs.rm(fs_join(target, "newdir"), recursive=True)
+            assert not fs.exists(fs_join(target, "newdir"))
+
+            # With recursive
+            for glob, recursive in zip(["*", "**"], [True, False]):
+                fs.put(local_join(source, "subdir", glob), t, recursive=recursive)
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert fs.isdir(fs_join(target, "newdir", "nesteddir"))
+                assert fs.isfile(fs_join(target, "newdir", "nesteddir", "nestedfile"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+                # Limit recursive by maxdepth
+                fs.put(
+                    local_join(source, "subdir", glob),
+                    t,
+                    recursive=recursive,
+                    maxdepth=1,
+                )
+                assert fs.isdir(fs_join(target, "newdir"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+                assert fs.isfile(fs_join(target, "newdir", "subfile2"))
+                assert not fs.exists(fs_join(target, "newdir", "nesteddir"))
+                assert not fs.exists(fs_join(target, "subdir"))
+                assert not fs.exists(fs_join(target, "newdir", "subdir"))
+
+                fs.rm(fs_join(target, "newdir"), recursive=True)
+                assert not fs.exists(fs_join(target, "newdir"))
+
+    @pytest.mark.parametrize(
+        GLOB_EDGE_CASES_TESTS["argnames"],
+        GLOB_EDGE_CASES_TESTS["argvalues"],
+    )
+    def test_put_glob_edge_cases(
+        self,
+        path,
+        recursive,
+        maxdepth,
+        expected,
+        fs,
+        fs_join,
+        fs_target,
+        local_glob_edge_cases_files,
+        local_join,
+        fs_sanitize_path,
+    ):
+        # Copy scenario 1g
+        source = local_glob_edge_cases_files
+
+        target = fs_target
+
+        for new_dir, target_slash in product([True, False], [True, False]):
+            fs.mkdir(target)
+
+            t = fs_join(target, "newdir") if new_dir else target
+            t = t + "/" if target_slash else t
+
+            fs.put(local_join(source, path), t, recursive=recursive, maxdepth=maxdepth)
+
+            output = fs.find(target)
+            if new_dir:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, "newdir", p)) for p in expected
+                ]
+            else:
+                prefixed_expected = [
+                    fs_sanitize_path(fs_join(target, p)) for p in expected
+                ]
+            assert sorted(output) == sorted(prefixed_expected)
+
+            try:
+                fs.rm(target, recursive=True)
+            except FileNotFoundError:
+                pass
+
+    def test_put_list_of_files_to_existing_directory(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_bulk_operations_scenario_0,
+        supports_empty_directories,
+    ):
+        # Copy scenario 2a
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+        if not supports_empty_directories:
+            # Force target directory to exist by adding a dummy file
+            dummy = fs_join(target, "dummy")
+            fs.touch(dummy)
+        assert fs.isdir(target)
+
+        source_files = [
+            local_join(source, "file1"),
+            local_join(source, "file2"),
+            local_join(source, "subdir", "subfile1"),
+        ]
+
+        for target_slash in [False, True]:
+            t = target + "/" if target_slash else target
+
+            fs.put(source_files, t)
+            assert fs.isfile(fs_join(target, "file1"))
+            assert fs.isfile(fs_join(target, "file2"))
+            assert fs.isfile(fs_join(target, "subfile1"))
+
+            fs.rm(
+                [
+                    fs_join(target, "file1"),
+                    fs_join(target, "file2"),
+                    fs_join(target, "subfile1"),
+                ],
+                recursive=True,
+            )
+            assert fs.ls(target, detail=False) == (
+                [] if supports_empty_directories else [dummy]
+            )
+
+    def test_put_list_of_files_to_new_directory(
+        self, fs, fs_join, fs_target, local_join, local_bulk_operations_scenario_0
+    ):
+        # Copy scenario 2b
+        source = local_bulk_operations_scenario_0
+
+        target = fs_target
+        fs.mkdir(target)
+
+        source_files = [
+            local_join(source, "file1"),
+            local_join(source, "file2"),
+            local_join(source, "subdir", "subfile1"),
+        ]
+
+        fs.put(source_files, fs_join(target, "newdir") + "/")  # Note trailing slash
+        assert fs.isdir(fs_join(target, "newdir"))
+        assert fs.isfile(fs_join(target, "newdir", "file1"))
+        assert fs.isfile(fs_join(target, "newdir", "file2"))
+        assert fs.isfile(fs_join(target, "newdir", "subfile1"))
+
+    def test_put_directory_recursive(
+        self, fs, fs_join, fs_target, local_fs, local_join, local_path
+    ):
+        # https://github.com/fsspec/filesystem_spec/issues/1062
+        # Recursive cp/get/put of source directory into non-existent target directory.
+        src = local_join(local_path, "src")
+        src_file = local_join(src, "file")
+        local_fs.mkdir(src)
+        local_fs.touch(src_file)
+
+        target = fs_target
+
+        # put without slash
+        assert not fs.exists(target)
+        for loop in range(2):
+            fs.put(src, target, recursive=True)
+            assert fs.isdir(target)
+
+            if loop == 0:
+                assert fs.isfile(fs_join(target, "file"))
+                assert not fs.exists(fs_join(target, "src"))
+            else:
+                assert fs.isfile(fs_join(target, "file"))
+                assert fs.isdir(fs_join(target, "src"))
+                assert fs.isfile(fs_join(target, "src", "file"))
+
+        fs.rm(target, recursive=True)
+
+        # put with slash
+        assert not fs.exists(target)
+        for loop in range(2):
+            fs.put(src + "/", target, recursive=True)
+            assert fs.isdir(target)
+            assert fs.isfile(fs_join(target, "file"))
+            assert not fs.exists(fs_join(target, "src"))
+
+    def test_put_directory_without_files_with_same_name_prefix(
+        self,
+        fs,
+        fs_join,
+        fs_target,
+        local_join,
+        local_dir_and_file_with_same_name_prefix,
+        supports_empty_directories,
+    ):
+        # Create the test dirs
+        source = local_dir_and_file_with_same_name_prefix
+        target = fs_target
+
+        # Test without glob
+        fs.put(local_join(source, "subdir"), fs_target, recursive=True)
+
+        assert fs.isfile(fs_join(fs_target, "subfile.txt"))
+        assert not fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+        fs.rm([fs_join(target, "subfile.txt")])
+        if supports_empty_directories:
+            assert fs.ls(target) == []
+        else:
+            assert not fs.exists(target)
+
+        # Test with glob
+        fs.put(local_join(source, "subdir*"), fs_target, recursive=True)
+
+        assert fs.isdir(fs_join(fs_target, "subdir"))
+        assert fs.isfile(fs_join(fs_target, "subdir", "subfile.txt"))
+        assert fs.isfile(fs_join(fs_target, "subdir.txt"))
+
+    def test_copy_with_source_and_destination_as_list(
+        self, fs, fs_target, fs_join, local_join, local_10_files_with_hashed_names
+    ):
+        # Create the test dir
+        source = local_10_files_with_hashed_names
+        target = fs_target
+
+        # Create list of files for source and destination
+        source_files = []
+        destination_files = []
+        for i in range(10):
+            hashed_i = md5(str(i).encode("utf-8")).hexdigest()
+            source_files.append(local_join(source, f"{hashed_i}.txt"))
+            destination_files.append(fs_join(target, f"{hashed_i}.txt"))
+
+        # Copy and assert order was kept
+        fs.put(lpath=source_files, rpath=destination_files)
+
+        for i in range(10):
+            file_content = fs.cat(destination_files[i]).decode("utf-8")
+            assert file_content == str(i)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/transaction.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/transaction.py
new file mode 100644
index 0000000000000000000000000000000000000000..70c5c0c070e1e13c4a5705b05b8773673871def3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/transaction.py
@@ -0,0 +1,113 @@
+import logging
+from collections import deque
+
+logger = logging.getLogger("fsspec")
+
+
+class Transaction:
+    """Filesystem transaction write context
+
+    Gathers files for deferred commit or discard, so that several write
+    operations can be finalized semi-atomically. This works by having this
+    instance as the ``.transaction`` attribute of the given filesystem
+    """
+
+    def __init__(self, fs, **kwargs):
+        """
+        Parameters
+        ----------
+        fs: FileSystem instance
+        """
+        self.fs = fs
+        self.files = deque()
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """End transaction and commit, if exit is not due to exception"""
+        # only commit if there was no exception
+        self.complete(commit=exc_type is None)
+        if self.fs:
+            self.fs._intrans = False
+            self.fs._transaction = None
+            self.fs = None
+
+    def start(self):
+        """Start a transaction on this FileSystem"""
+        self.files = deque()  # clean up after previous failed completions
+        self.fs._intrans = True
+
+    def complete(self, commit=True):
+        """Finish transaction: commit or discard all deferred files"""
+        f = None
+        try:
+            while self.files:
+                f = self.files.popleft()
+                if commit:
+                    f.commit()
+                else:
+                    f.discard()
+                f = None
+        finally:
+            # the file being processed when the error was raised is already
+            # off the queue; put it back so its temporary file is cleaned up
+            if f is not None:
+                self.files.appendleft(f)
+            # A failed commit or discard must still end the transaction.
+            # Leaving _intrans set would defer every later write on this
+            # filesystem into a temporary file that nothing ever commits,
+            # and instances are cached, so that would persist process-wide.
+            while self.files:
+                try:
+                    self.files.popleft().discard()
+                except Exception:
+                    logger.debug("Discarding deferred file failed", exc_info=True)
+            self.fs._intrans = False
+            self.fs._transaction = None
+            self.fs = None
+
+
+class FileActor:
+    def __init__(self):
+        self.files = []
+
+    def commit(self):
+        for f in self.files:
+            f.commit()
+        self.files.clear()
+
+    def discard(self):
+        for f in self.files:
+            f.discard()
+        self.files.clear()
+
+    def append(self, f):
+        self.files.append(f)
+
+
+class DaskTransaction(Transaction):
+    def __init__(self, fs):
+        """
+        Parameters
+        ----------
+        fs: FileSystem instance
+        """
+        import distributed
+
+        super().__init__(fs)
+        client = distributed.default_client()
+        self.files = client.submit(FileActor, actor=True).result()
+
+    def complete(self, commit=True):
+        """Finish transaction: commit or discard all deferred files"""
+        try:
+            if commit:
+                self.files.commit().result()
+            else:
+                self.files.discard().result()
+        finally:
+            self.fs._intrans = False
+            self.fs._transaction = None
+            self.fs = None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..5691de229c85f39f6634e5a7eb84d5fab64b6e3e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/fsspec/utils.py
@@ -0,0 +1,856 @@
+from __future__ import annotations
+
+import contextlib
+import ctypes
+import logging
+import math
+import os
+import re
+import sys
+import tempfile
+from collections.abc import Callable, Iterable, Iterator, Sequence
+from functools import partial
+from hashlib import md5
+from importlib.metadata import version
+from typing import IO, TYPE_CHECKING, Any, TypeVar
+from urllib.parse import urlsplit
+
+if TYPE_CHECKING:
+    import pathlib
+    from typing import TypeGuard
+
+    from fsspec.spec import AbstractFileSystem
+
+
+DEFAULT_BLOCK_SIZE = 5 * 2**20
+
+T = TypeVar("T")
+
+
+def infer_storage_options(
+    urlpath: str, inherit_storage_options: dict[str, Any] | None = None
+) -> dict[str, Any]:
+    """Infer storage options from URL path and merge it with existing storage
+    options.
+
+    Parameters
+    ----------
+    urlpath: str or unicode
+        Either local absolute file path or URL (hdfs://namenode:8020/file.csv)
+    inherit_storage_options: dict (optional)
+        Its contents will get merged with the inferred information from the
+        given path
+
+    Returns
+    -------
+    Storage options dict.
+
+    Examples
+    --------
+    >>> infer_storage_options('/mnt/datasets/test.csv')  # doctest: +SKIP
+    {"protocol": "file", "path", "/mnt/datasets/test.csv"}
+    >>> infer_storage_options(
+    ...     'hdfs://username:pwd@node:123/mnt/datasets/test.csv?q=1',
+    ...     inherit_storage_options={'extra': 'value'},
+    ... )  # doctest: +SKIP
+    {"protocol": "hdfs", "username": "username", "password": "pwd",
+    "host": "node", "port": 123, "path": "/mnt/datasets/test.csv",
+    "url_query": "q=1", "extra": "value"}
+    """
+
+    # Discover Windows paths including disk name in this special case.
+    is_filesystem = re.match(r"^[a-zA-Z]:[\\/]", urlpath)
+
+    # Discover URI according to RFC 3986: Scheme names consist of a
+    # sequence of characters beginning with a letter and followed by
+    # any combination of letters, digits, plus ("+"), period ("."),
+    # or hyphen ("-").
+    # https://datatracker.ietf.org/doc/html/rfc3986#section-3.1
+    is_uri = re.match(r"^[a-zA-Z0-9+.-]+://", urlpath)
+
+    if is_filesystem or is_uri is None:
+        return {"protocol": "file", "path": urlpath}
+
+    parsed_path = urlsplit(urlpath)
+    protocol = parsed_path.scheme or "file"
+    if parsed_path.fragment:
+        path = "#".join([parsed_path.path, parsed_path.fragment])
+    else:
+        path = parsed_path.path
+    if protocol == "file":
+        # Special case parsing file protocol URL on Windows according to:
+        # https://msdn.microsoft.com/en-us/library/jj710207.aspx
+        windows_path = re.match(r"^/([a-zA-Z])[:|]([\\/].*)$", path)
+        if windows_path:
+            drive, path = windows_path.groups()
+            path = f"{drive}:{path}"
+
+    if protocol in ["http", "https"]:
+        # for HTTP, we don't want to parse, as requests will anyway
+        return {"protocol": protocol, "path": urlpath}
+
+    options: dict[str, Any] = {"protocol": protocol, "path": path}
+
+    if parsed_path.netloc:
+        # Parse `hostname` from netloc manually because `parsed_path.hostname`
+        # lowercases the hostname which is not always desirable (e.g. in S3):
+        # https://github.com/dask/dask/issues/1417
+        options["host"] = parsed_path.netloc.rsplit("@", 1)[-1].rsplit(":", 1)[0]
+
+        if protocol in ("s3", "s3a", "gcs", "gs"):
+            options["path"] = options["host"] + options["path"]
+        else:
+            options["host"] = options["host"]
+        if parsed_path.port:
+            options["port"] = parsed_path.port
+        if parsed_path.username:
+            options["username"] = parsed_path.username
+        if parsed_path.password:
+            options["password"] = parsed_path.password
+
+    if parsed_path.query:
+        options["url_query"] = parsed_path.query
+    if parsed_path.fragment:
+        options["url_fragment"] = parsed_path.fragment
+
+    if inherit_storage_options:
+        update_storage_options(options, inherit_storage_options)
+
+    return options
+
+
+def update_storage_options(
+    options: dict[str, Any], inherited: dict[str, Any] | None = None
+) -> None:
+    if not inherited:
+        inherited = {}
+    collisions = set(options) & set(inherited)
+    if collisions:
+        for collision in collisions:
+            if options.get(collision) != inherited.get(collision):
+                raise KeyError(
+                    f"Collision between inferred and specified storage "
+                    f"option:\n{collision}"
+                )
+    options.update(inherited)
+
+
+# Compression extensions registered via fsspec.compression.register_compression
+compressions: dict[str, str] = {}
+
+
+def infer_compression(filename: str) -> str | None:
+    """Infer compression, if available, from filename.
+
+    Infer a named compression type, if registered and available, from filename
+    extension. This includes builtin (gz, bz2, zip) compressions, as well as
+    optional compressions. See fsspec.compression.register_compression.
+    """
+    extension = os.path.splitext(filename)[-1].strip(".").lower()
+    if extension in compressions:
+        return compressions[extension]
+    return None
+
+
+def build_name_function(max_int: float) -> Callable[[int], str]:
+    """Returns a function that receives a single integer
+    and returns it as a string padded by enough zero characters
+    to align with maximum possible integer
+
+    >>> name_f = build_name_function(57)
+
+    >>> name_f(7)
+    '07'
+    >>> name_f(31)
+    '31'
+    >>> build_name_function(1000)(42)
+    '0042'
+    >>> build_name_function(999)(42)
+    '042'
+    >>> build_name_function(0)(0)
+    '0'
+    """
+    # handle corner cases max_int is 0 or exact power of 10
+    max_int += 1e-8
+
+    pad_length = int(math.ceil(math.log10(max_int)))
+
+    def name_function(i: int) -> str:
+        return str(i).zfill(pad_length)
+
+    return name_function
+
+
+def seek_delimiter(file: IO[bytes], delimiter: bytes, blocksize: int) -> bool:
+    r"""Seek current file to file start, file end, or byte after delimiter seq.
+
+    Seeks file to next chunk delimiter, where chunks are defined on file start,
+    a delimiting sequence, and file end. Use file.tell() to see location afterwards.
+    Note that file start is a valid split, so must be at offset > 0 to seek for
+    delimiter.
+
+    Parameters
+    ----------
+    file: a file
+    delimiter: bytes
+        a delimiter like ``b'\n'`` or message sentinel, matching file .read() type
+    blocksize: int
+        Number of bytes to read from the file at once.
+
+
+    Returns
+    -------
+    Returns True if a delimiter was found, False if at file start or end.
+
+    """
+
+    if file.tell() == 0:
+        # beginning-of-file, return without seek
+        return False
+
+    # Interface is for binary IO, with delimiter as bytes, but initialize last
+    # with result of file.read to preserve compatibility with text IO.
+    last: bytes | None = None
+    while True:
+        current = file.read(blocksize)
+        if not current:
+            # end-of-file without delimiter
+            return False
+        full = last + current if last else current
+        try:
+            if delimiter in full:
+                i = full.index(delimiter)
+                file.seek(file.tell() - (len(full) - i) + len(delimiter))
+                return True
+            elif len(current) < blocksize:
+                # end-of-file without delimiter
+                return False
+        except (OSError, ValueError):
+            pass
+        last = full[-len(delimiter) :]
+
+
+def read_block(
+    f: IO[bytes],
+    offset: int,
+    length: int | None,
+    delimiter: bytes | None = None,
+    split_before: bool = False,
+) -> bytes:
+    """Read a block of bytes from a file
+
+    Parameters
+    ----------
+    f: File
+        Open file
+    offset: int
+        Byte offset to start read
+    length: int
+        Number of bytes to read, read through end of file if None
+    delimiter: bytes (optional)
+        Ensure reading starts and stops at delimiter bytestring
+    split_before: bool (optional)
+        Start/stop read *before* delimiter bytestring.
+
+
+    If using the ``delimiter=`` keyword argument we ensure that the read
+    starts and stops at delimiter boundaries that follow the locations
+    ``offset`` and ``offset + length``.  If ``offset`` is zero then we
+    start at zero, regardless of delimiter.  The bytestring returned WILL
+    include the terminating delimiter string.
+
+    Examples
+    --------
+
+    >>> from io import BytesIO  # doctest: +SKIP
+    >>> f = BytesIO(b'Alice, 100\\nBob, 200\\nCharlie, 300')  # doctest: +SKIP
+    >>> read_block(f, 0, 13)  # doctest: +SKIP
+    b'Alice, 100\\nBo'
+
+    >>> read_block(f, 0, 13, delimiter=b'\\n')  # doctest: +SKIP
+    b'Alice, 100\\nBob, 200\\n'
+
+    >>> read_block(f, 10, 10, delimiter=b'\\n')  # doctest: +SKIP
+    b'Bob, 200\\nCharlie, 300'
+    """
+    if delimiter:
+        f.seek(offset)
+        found_start_delim = seek_delimiter(f, delimiter, 2**16)
+        if length is None:
+            return f.read()
+        start = f.tell()
+        length -= start - offset
+
+        f.seek(start + length)
+        found_end_delim = seek_delimiter(f, delimiter, 2**16)
+        end = f.tell()
+
+        # Adjust split location to before delimiter if seek found the
+        # delimiter sequence, not start or end of file.
+        if found_start_delim and split_before:
+            start -= len(delimiter)
+
+        if found_end_delim and split_before:
+            end -= len(delimiter)
+
+        offset = start
+        length = end - start
+
+    f.seek(offset)
+
+    # TODO: allow length to be None and read to the end of the file?
+    assert length is not None
+    b = f.read(length)
+    return b
+
+
+def tokenize(*args: Any, **kwargs: Any) -> str:
+    """Deterministic token
+
+    (modified from dask.base)
+
+    >>> tokenize([1, 2, '3'])
+    '9d71491b50023b06fc76928e6eddb952'
+
+    >>> tokenize('Hello') == tokenize('Hello')
+    True
+    """
+    if kwargs:
+        args += (kwargs,)
+    try:
+        h = md5(str(args).encode())
+    except ValueError:
+        # FIPS systems: https://github.com/fsspec/filesystem_spec/issues/380
+        h = md5(str(args).encode(), usedforsecurity=False)
+    return h.hexdigest()
+
+
+def stringify_path(filepath: str | os.PathLike[str] | pathlib.Path) -> str:
+    """Attempt to convert a path-like object to a string.
+
+    Parameters
+    ----------
+    filepath: object to be converted
+
+    Returns
+    -------
+    filepath_str: maybe a string version of the object
+
+    Notes
+    -----
+    Objects supporting the fspath protocol are coerced according to its
+    __fspath__ method.
+
+    For backwards compatibility with older Python version, pathlib.Path
+    objects are specially coerced.
+
+    Any other object is passed through unchanged, which includes bytes,
+    strings, buffers, or anything else that's not even path-like.
+    """
+    if isinstance(filepath, str):
+        return filepath
+    elif hasattr(filepath, "__fspath__"):
+        return filepath.__fspath__()
+    elif hasattr(filepath, "path"):
+        return filepath.path
+    else:
+        return filepath  # type: ignore[return-value]
+
+
+def make_instance(
+    cls: Callable[..., T], args: Sequence[Any], kwargs: dict[str, Any]
+) -> T:
+    inst = cls(*args, **kwargs)
+    inst._determine_worker()  # type: ignore[attr-defined]
+    return inst
+
+
+def common_prefix(paths: Iterable[str]) -> str:
+    """For a list of paths, find the shortest prefix common to all"""
+    parts = [p.split("/") for p in paths]
+    lmax = min(len(p) for p in parts)
+    end = 0
+    for i in range(lmax):
+        end = all(p[i] == parts[0][i] for p in parts)
+        if not end:
+            break
+    i += end
+    return "/".join(parts[0][:i])
+
+
+def other_paths(
+    paths: list[str],
+    path2: str | list[str],
+    exists: bool = False,
+    flatten: bool = False,
+) -> list[str]:
+    """In bulk file operations, construct a new file tree from a list of files
+
+    Parameters
+    ----------
+    paths: list of str
+        The input file tree
+    path2: str or list of str
+        Root to construct the new list in. If this is already a list of str, we just
+        assert it has the right number of elements.
+    exists: bool (optional)
+        For a str destination, it is already exists (and is a dir), files should
+        end up inside.
+    flatten: bool (optional)
+        Whether to flatten the input directory tree structure so that the output files
+        are in the same directory.
+
+    Returns
+    -------
+    list of str
+    """
+
+    if isinstance(path2, str):
+        path2 = path2.rstrip("/")
+
+        if flatten:
+            path2 = ["/".join((path2, p.split("/")[-1])) for p in paths]
+        else:
+            cp = common_prefix(paths)
+            if exists:
+                cp = cp.rsplit("/", 1)[0]
+            if not cp and all(not s.startswith("/") for s in paths):
+                path2 = ["/".join([path2, p]) for p in paths]
+            else:
+                path2 = [p.replace(cp, path2, 1) for p in paths]
+    else:
+        assert len(paths) == len(path2)
+    return path2
+
+
+def check_contained(root: str, paths: list[str]) -> None:
+    """Raise if any of ``paths`` lies outside the destination ``root``.
+
+    Bulk copies build their destination names by joining source names onto a
+    destination root. Those names come from the source listing, so a name
+    holding ".." segments resolves above the root and writes outside the
+    destination the caller asked for.
+
+    Parameters
+    ----------
+    root: str
+        The destination the caller passed.
+    paths: list of str
+        The destination names built for that root.
+    """
+    root_abs = os.path.abspath(root)
+    # normcase so that a case-insensitive platform does not report a false
+    # escape, while the message keeps the paths as the caller would see them.
+    root_key = os.path.normcase(root_abs)
+    prefix = root_key.rstrip(os.sep) + os.sep
+    for path in paths:
+        path_abs = os.path.abspath(path)
+        path_key = os.path.normcase(path_abs)
+        if path_key != root_key and not path_key.startswith(prefix):
+            raise ValueError(
+                f"path {path!r} would be copied to {path_abs!r}, which is "
+                f"outside the destination {root!r}"
+            )
+
+
+def is_exception(obj: Any) -> bool:
+    return isinstance(obj, BaseException)
+
+
+def isfilelike(f: Any) -> TypeGuard[IO[bytes]]:
+    return all(hasattr(f, attr) for attr in ["read", "close", "tell"])
+
+
+def get_protocol(url: str) -> str:
+    url = stringify_path(url)
+    parts = re.split(r"(\:\:|\://)", url, maxsplit=1)
+    if len(parts) > 1:
+        return parts[0]
+    return "file"
+
+
+def get_file_extension(url: str) -> str:
+    url = stringify_path(url)
+    # Only consider the final path component: a "." in a parent directory name
+    # (e.g. "/path/to.dir/file") is not the file's extension.
+    ext_parts = url.rsplit("/", 1)[-1].rsplit(".", 1)
+    if len(ext_parts) > 1:
+        return ext_parts[-1]
+    return ""
+
+
+def can_be_local(path: str) -> bool:
+    """Can the given URL be used with open_local?"""
+    from fsspec import get_filesystem_class
+
+    try:
+        return getattr(get_filesystem_class(get_protocol(path)), "local_file", False)
+    except (ValueError, ImportError):
+        # not in registry or import failed
+        return False
+
+
+def get_package_version_without_import(name: str) -> str | None:
+    """For given package name, try to find the version without importing it
+
+    Import and package.__version__ is still the backup here, so an import
+    *might* happen.
+
+    Returns either the version string, or None if the package
+    or the version was not readily  found.
+    """
+    if name in sys.modules:
+        mod = sys.modules[name]
+        if hasattr(mod, "__version__"):
+            return mod.__version__
+    try:
+        return version(name)
+    except:  # noqa: E722
+        pass
+    try:
+        import importlib
+
+        mod = importlib.import_module(name)
+        return mod.__version__
+    except (ImportError, AttributeError):
+        return None
+
+
+def setup_logging(
+    logger: logging.Logger | None = None,
+    logger_name: str | None = None,
+    level: str = "DEBUG",
+    clear: bool = True,
+) -> logging.Logger:
+    if logger is None and logger_name is None:
+        raise ValueError("Provide either logger object or logger name")
+    logger = logger or logging.getLogger(logger_name)
+    handle = logging.StreamHandler()
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(funcName)s -- %(message)s"
+    )
+    handle.setFormatter(formatter)
+    if clear:
+        logger.handlers.clear()
+    logger.addHandler(handle)
+    logger.setLevel(level)
+    return logger
+
+
+def _unstrip_protocol(name: str, fs: AbstractFileSystem) -> str:
+    return fs.unstrip_protocol(name)
+
+
+def mirror_from(
+    origin_name: str, methods: Iterable[str]
+) -> Callable[[type[T]], type[T]]:
+    """Mirror attributes and methods from the given
+    origin_name attribute of the instance to the
+    decorated class"""
+
+    def origin_getter(method: str, self: Any) -> Any:
+        origin = getattr(self, origin_name)
+        return getattr(origin, method)
+
+    def wrapper(cls: type[T]) -> type[T]:
+        for method in methods:
+            wrapped_method = partial(origin_getter, method)
+            setattr(cls, method, property(wrapped_method))
+        return cls
+
+    return wrapper
+
+
+@contextlib.contextmanager
+def nullcontext(obj: T) -> Iterator[T]:
+    yield obj
+
+
+def merge_offset_ranges(
+    paths: list[str],
+    starts: list[int | None] | int | None,
+    ends: list[int | None] | int | None,
+    max_gap: int = 0,
+    max_block: int | None = None,
+    sort: bool = True,
+) -> tuple[list[str], list[int], list[int | None]]:
+    """Merge adjacent byte-offset ranges when the inter-range
+    gap is <= `max_gap`, and when the merged byte range does not
+    exceed `max_block` (if specified). Every input range is covered by
+    at least one returned range. Overlapping input ranges are merged
+    where `max_block` allows it, so returned ranges may overlap once a
+    chain of overlapping inputs reaches `max_block`; a single input
+    range larger than `max_block` is still returned whole.
+
+    An `end` of `None` means to the end of the file. By default, this
+    function will re-order the input paths and byte ranges to ensure
+    sorted order.
+
+    Passing `sort=False` skips the re-ordering, which is only worthwhile
+    when the inputs are already grouped by path and ascending by start
+    within each path. Ranges that break that order still appear in the
+    output, as their own range rather than merged, so coverage holds for
+    any input order.
+    """
+    # Check input
+    if not isinstance(paths, list):
+        raise TypeError
+    if not isinstance(starts, list):
+        starts = [starts] * len(paths)
+    if not isinstance(ends, list):
+        ends = [ends] * len(paths)
+    if len(starts) != len(paths) or len(ends) != len(paths):
+        raise ValueError
+
+    starts_i: list[int] = [s or 0 for s in starts]
+    ends_i: list[int | None] = ends
+
+    # Early Return
+    if len(starts_i) <= 1:
+        return paths, starts_i, ends_i
+
+    # Sort by paths and then ranges if `sort=True`
+    if sort:
+        ranges = sorted(
+            zip(paths, starts_i, ends_i),
+            # None end sorts last (covers furthest into the file)
+            key=lambda pse: (pse[0], pse[1], math.inf if pse[2] is None else pse[2]),
+        )
+        paths = [r[0] for r in ranges]
+        starts_i = [r[1] for r in ranges]
+        ends_i = [r[2] for r in ranges]
+
+    # Loop through the coupled `paths`, `starts`, and
+    # `ends`, and merge adjacent blocks when appropriate
+    new_paths = paths[:1]
+    new_starts = starts_i[:1]
+    new_ends = ends_i[:1]
+    for path, start, end in zip(paths[1:], starts_i[1:], ends_i[1:]):
+        prev_end = new_ends[-1]
+        if path != new_paths[-1]:
+            # Cannot merge with previous block
+            new_paths.append(path)
+            new_starts.append(start)
+            new_ends.append(end)
+        elif start < new_starts[-1]:
+            # Out of order (only possible when `sort=False`). Walking the
+            # current block start backwards would uncover bytes already
+            # attributed to it, so give this range its own block
+            new_paths.append(path)
+            new_starts.append(start)
+            new_ends.append(end)
+        elif prev_end is None:
+            # Previous block already covers the rest of the file
+            continue
+        elif start < prev_end:
+            # Overlap / nested
+            if end is not None and end <= prev_end:
+                # Already covered by the current block
+                continue
+            elif (
+                end is not None
+                and max_block is not None
+                and (end - new_starts[-1]) > max_block
+            ):
+                # Extending would exceed `max_block`. Start a new block,
+                # which overlaps the previous one, rather than letting a
+                # chain of overlaps grow the block without bound
+                new_paths.append(path)
+                new_starts.append(start)
+                new_ends.append(end)
+            else:
+                # An `end` of None extends the block to EOF; a separate
+                # block would subsume the current one anyway
+                new_ends[-1] = end
+        elif (start - prev_end) > max_gap or (
+            max_block is not None
+            and (end is None or (end - new_starts[-1]) > max_block)
+        ):
+            # Gap too large, or merging would exceed `max_block`
+            new_paths.append(path)
+            new_starts.append(start)
+            new_ends.append(end)
+        else:
+            # Merge with the previous block
+            new_ends[-1] = end
+
+    return new_paths, new_starts, new_ends
+
+
+def file_size(filelike: IO[bytes]) -> int:
+    """Find length of any open read-mode file-like"""
+    pos = filelike.tell()
+    try:
+        return filelike.seek(0, 2)
+    finally:
+        filelike.seek(pos)
+
+
+@contextlib.contextmanager
+def atomic_write(path: str, mode: str = "wb"):
+    """
+    A context manager that opens a temporary file next to `path` and, on exit,
+    replaces `path` with the temporary file, thereby updating `path`
+    atomically.
+    """
+    fd, fn = tempfile.mkstemp(
+        dir=os.path.dirname(path), prefix=os.path.basename(path) + "-"
+    )
+    try:
+        with open(fd, mode) as fp:
+            yield fp
+    except BaseException:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(fn)
+        raise
+    else:
+        os.replace(fn, path)
+
+
+def _translate(pat, STAR, QUESTION_MARK):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    res: list[str] = []
+    add = res.append
+    i, n = 0, len(pat)
+    while i < n:
+        c = pat[i]
+        i = i + 1
+        if c == "*":
+            # compress consecutive `*` into one
+            if (not res) or res[-1] is not STAR:
+                add(STAR)
+        elif c == "?":
+            add(QUESTION_MARK)
+        elif c == "[":
+            j = i
+            if j < n and pat[j] == "!":
+                j = j + 1
+            if j < n and pat[j] == "]":
+                j = j + 1
+            while j < n and pat[j] != "]":
+                j = j + 1
+            if j >= n:
+                add("\\[")
+            else:
+                stuff = pat[i:j]
+                if "-" not in stuff:
+                    stuff = stuff.replace("\\", r"\\")
+                else:
+                    chunks = []
+                    k = i + 2 if pat[i] == "!" else i + 1
+                    while True:
+                        k = pat.find("-", k, j)
+                        if k < 0:
+                            break
+                        chunks.append(pat[i:k])
+                        i = k + 1
+                        k = k + 3
+                    chunk = pat[i:j]
+                    if chunk:
+                        chunks.append(chunk)
+                    else:
+                        chunks[-1] += "-"
+                    # Remove empty ranges -- invalid in RE.
+                    for k in range(len(chunks) - 1, 0, -1):
+                        if chunks[k - 1][-1] > chunks[k][0]:
+                            chunks[k - 1] = chunks[k - 1][:-1] + chunks[k][1:]
+                            del chunks[k]
+                    # Escape backslashes and hyphens for set difference (--).
+                    # Hyphens that create ranges shouldn't be escaped.
+                    stuff = "-".join(
+                        s.replace("\\", r"\\").replace("-", r"\-") for s in chunks
+                    )
+                # Escape set operations (&&, ~~ and ||).
+                stuff = re.sub(r"([&~|])", r"\\\1", stuff)
+                i = j + 1
+                if not stuff:
+                    # Empty range: never match.
+                    add("(?!)")
+                elif stuff == "!":
+                    # Negated empty range: match any character.
+                    add(".")
+                else:
+                    if stuff[0] == "!":
+                        stuff = "^" + stuff[1:]
+                    elif stuff[0] in ("^", "["):
+                        stuff = "\\" + stuff
+                    add(f"[{stuff}]")
+        else:
+            add(re.escape(c))
+    assert i == n
+    return res
+
+
+def glob_translate(pat):
+    # Copied from: https://github.com/python/cpython/pull/106703.
+    # The keyword parameters' values are fixed to:
+    # recursive=True, include_hidden=True, seps="/"
+    """Translate a pathname with shell wildcards to a regular expression."""
+    # fsspec paths always use "/" as their separator (AbstractFileSystem.sep), on every
+    # platform, and glob() has already put the pattern through _strip_protocol by the
+    # time it reaches here. Taking the separators from os.path instead would make a
+    # backslash a separator on Windows only, so a key containing one, which is an
+    # ordinary character on an object store, would stop matching there.
+    seps = "/"
+    escaped_seps = "".join(map(re.escape, seps))
+    any_sep = f"[{escaped_seps}]" if len(seps) > 1 else escaped_seps
+    not_sep = f"[^{escaped_seps}]"
+    one_last_segment = f"{not_sep}+"
+    one_segment = f"{one_last_segment}{any_sep}"
+    any_segments = f"(?:.+{any_sep})?"
+    any_last_segments = ".*"
+    results = []
+    parts = re.split(any_sep, pat)
+    last_part_idx = len(parts) - 1
+    for idx, part in enumerate(parts):
+        if part == "*":
+            results.append(one_segment if idx < last_part_idx else one_last_segment)
+            continue
+        if part == "**":
+            results.append(any_segments if idx < last_part_idx else any_last_segments)
+            continue
+        elif "**" in part:
+            raise ValueError(
+                "Invalid pattern: '**' can only be an entire path component"
+            )
+        if part:
+            results.extend(_translate(part, f"{not_sep}*", not_sep))
+        if idx < last_part_idx:
+            results.append(any_sep)
+    res = "".join(results)
+    return rf"(?s:{res})\Z"
+
+
+try:
+    PyBytes_FromStringAndSize = ctypes.pythonapi.PyBytes_FromStringAndSize
+    PyBytes_FromStringAndSize.argtypes = (ctypes.c_void_p, ctypes.c_ssize_t)
+    PyBytes_FromStringAndSize.restype = ctypes.py_object
+
+    PyBytes_AsString = ctypes.pythonapi.PyBytes_AsString
+    PyBytes_AsString.argtypes = (ctypes.py_object,)
+    PyBytes_AsString.restype = ctypes.c_void_p
+    HAS_CPYTHON_API = True
+except Exception:
+    PyBytes_FromStringAndSize = None
+    PyBytes_AsString = None
+    HAS_CPYTHON_API = False
+
+
+# Please refer to following discussion to understand why this is required at this point
+# Discussion = https://github.com/fsspec/gcsfs/pull/795#discussion_r3032749881
+def _fast_slice(src_bytes: bytes, offset: int, read_size: int) -> bytes:
+    if read_size == 0:
+        return b""
+    if offset < 0 or offset + read_size > len(src_bytes):
+        raise ValueError("Slice indices out of bounds")
+
+    if HAS_CPYTHON_API:
+        dest_bytes = PyBytes_FromStringAndSize(None, read_size)
+        src_ptr = PyBytes_AsString(src_bytes)
+        dest_ptr = PyBytes_AsString(dest_bytes)
+        # Releases the GIL
+        ctypes.memmove(dest_ptr, src_ptr + offset, read_size)
+        return dest_bytes
+    else:
+        # Standard fallback for PyPy/non-CPython
+        return src_bytes[offset : offset + read_size]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..8a2f639061cc4a203f7109d8335d28076442c61d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/METADATA
@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: h11
+Version: 0.16.0
+Summary: A pure-Python, bring-your-own-I/O implementation of HTTP/1.1
+Home-page: https://github.com/python-hyper/h11
+Author: Nathaniel J. Smith
+Author-email: njs@pobox.com
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.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
+Classifier: Topic :: System :: Networking
+Requires-Python: >=3.8
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+h11
+===
+
+.. image:: https://travis-ci.org/python-hyper/h11.svg?branch=master
+   :target: https://travis-ci.org/python-hyper/h11
+   :alt: Automated test status
+
+.. image:: https://codecov.io/gh/python-hyper/h11/branch/master/graph/badge.svg
+   :target: https://codecov.io/gh/python-hyper/h11
+   :alt: Test coverage
+
+.. image:: https://readthedocs.org/projects/h11/badge/?version=latest
+   :target: http://h11.readthedocs.io/en/latest/?badge=latest
+   :alt: Documentation Status
+
+This is a little HTTP/1.1 library written from scratch in Python,
+heavily inspired by `hyper-h2 <https://hyper-h2.readthedocs.io/>`_.
+
+It's a "bring-your-own-I/O" library; h11 contains no IO code
+whatsoever. This means you can hook h11 up to your favorite network
+API, and that could be anything you want: synchronous, threaded,
+asynchronous, or your own implementation of `RFC 6214
+<https://tools.ietf.org/html/rfc6214>`_ -- h11 won't judge you.
+(Compare this to the current state of the art, where every time a `new
+network API <https://trio.readthedocs.io/>`_ comes along then someone
+gets to start over reimplementing the entire HTTP protocol from
+scratch.) Cory Benfield made an `excellent blog post describing the
+benefits of this approach
+<https://lukasa.co.uk/2015/10/The_New_Hyper/>`_, or if you like video
+then here's his `PyCon 2016 talk on the same theme
+<https://www.youtube.com/watch?v=7cC3_jGwl_U>`_.
+
+This also means that h11 is not immediately useful out of the box:
+it's a toolkit for building programs that speak HTTP, not something
+that could directly replace ``requests`` or ``twisted.web`` or
+whatever. But h11 makes it much easier to implement something like
+``requests`` or ``twisted.web``.
+
+At a high level, working with h11 goes like this:
+
+1) First, create an ``h11.Connection`` object to track the state of a
+   single HTTP/1.1 connection.
+
+2) When you read data off the network, pass it to
+   ``conn.receive_data(...)``; you'll get back a list of objects
+   representing high-level HTTP "events".
+
+3) When you want to send a high-level HTTP event, create the
+   corresponding "event" object and pass it to ``conn.send(...)``;
+   this will give you back some bytes that you can then push out
+   through the network.
+
+For example, a client might instantiate and then send a
+``h11.Request`` object, then zero or more ``h11.Data`` objects for the
+request body (e.g., if this is a POST), and then a
+``h11.EndOfMessage`` to indicate the end of the message. Then the
+server would then send back a ``h11.Response``, some ``h11.Data``, and
+its own ``h11.EndOfMessage``. If either side violates the protocol,
+you'll get a ``h11.ProtocolError`` exception.
+
+h11 is suitable for implementing both servers and clients, and has a
+pleasantly symmetric API: the events you send as a client are exactly
+the ones that you receive as a server and vice-versa.
+
+`Here's an example of a tiny HTTP client
+<https://github.com/python-hyper/h11/blob/master/examples/basic-client.py>`_
+
+It also has `a fine manual <https://h11.readthedocs.io/>`_.
+
+FAQ
+---
+
+*Whyyyyy?*
+
+I wanted to play with HTTP in `Curio
+<https://curio.readthedocs.io/en/latest/tutorial.html>`__ and `Trio
+<https://trio.readthedocs.io>`__, which at the time didn't have any
+HTTP libraries. So I thought, no big deal, Python has, like, a dozen
+different implementations of HTTP, surely I can find one that's
+reusable. I didn't find one, but I did find Cory's call-to-arms
+blog-post. So I figured, well, fine, if I have to implement HTTP from
+scratch, at least I can make sure no-one *else* has to ever again.
+
+*Should I use it?*
+
+Maybe. You should be aware that it's a very young project. But, it's
+feature complete and has an exhaustive test-suite and complete docs,
+so the next step is for people to try using it and see how it goes
+:-). If you do then please let us know -- if nothing else we'll want
+to talk to you before making any incompatible changes!
+
+*What are the features/limitations?*
+
+Roughly speaking, it's trying to be a robust, complete, and non-hacky
+implementation of the first "chapter" of the HTTP/1.1 spec: `RFC 7230:
+HTTP/1.1 Message Syntax and Routing
+<https://tools.ietf.org/html/rfc7230>`_. That is, it mostly focuses on
+implementing HTTP at the level of taking bytes on and off the wire,
+and the headers related to that, and tries to be anal about spec
+conformance. It doesn't know about higher-level concerns like URL
+routing, conditional GETs, cross-origin cookie policies, or content
+negotiation. But it does know how to take care of framing,
+cross-version differences in keep-alive handling, and the "obsolete
+line folding" rule, so you can focus your energies on the hard /
+interesting parts for your application, and it tries to support the
+full specification in the sense that any useful HTTP/1.1 conformant
+application should be able to use h11.
+
+It's pure Python, and has no dependencies outside of the standard
+library.
+
+It has a test suite with 100.0% coverage for both statements and
+branches.
+
+Currently it supports Python 3 (testing on 3.8-3.12) and PyPy 3.
+The last Python 2-compatible version was h11 0.11.x.
+(Originally it had a Cython wrapper for `http-parser
+<https://github.com/nodejs/http-parser>`_ and a beautiful nested state
+machine implemented with ``yield from`` to postprocess the output. But
+I had to take these out -- the new *parser* needs fewer lines-of-code
+than the old *parser wrapper*, is written in pure Python, uses no
+exotic language syntax, and has more features. It's sad, really; that
+old state machine was really slick. I just need a few sentences here
+to mourn that.)
+
+I don't know how fast it is. I haven't benchmarked or profiled it yet,
+so it's probably got a few pointless hot spots, and I've been trying
+to err on the side of simplicity and robustness instead of
+micro-optimization. But at the architectural level I tried hard to
+avoid fundamentally bad decisions, e.g., I believe that all the
+parsing algorithms remain linear-time even in the face of pathological
+input like slowloris, and there are no byte-by-byte loops. (I also
+believe that it maintains bounded memory usage in the face of
+arbitrary/pathological input.)
+
+The whole library is ~800 lines-of-code. You can read and understand
+the whole thing in less than an hour. Most of the energy invested in
+this so far has been spent on trying to keep things simple by
+minimizing special-cases and ad hoc state manipulation; even though it
+is now quite small and simple, I'm still annoyed that I haven't
+figured out how to make it even smaller and simpler. (Unfortunately,
+HTTP does not lend itself to simplicity.)
+
+The API is ~feature complete and I don't expect the general outlines
+to change much, but you can't judge an API's ergonomics until you
+actually document and use it, so I'd expect some changes in the
+details.
+
+*How do I try it?*
+
+.. code-block:: sh
+
+  $ pip install h11
+  $ git clone git@github.com:python-hyper/h11
+  $ cd h11/examples
+  $ python basic-client.py
+
+and go from there.
+
+*License?*
+
+MIT
+
+*Code of conduct?*
+
+Contributors are requested to follow our `code of conduct
+<https://github.com/python-hyper/h11/blob/master/CODE_OF_CONDUCT.md>`_ in
+all project spaces.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..8768040c3cd11d4e09e697b8fc3b40c693c48cd4
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/RECORD
@@ -0,0 +1,29 @@
+h11-0.16.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+h11-0.16.0.dist-info/METADATA,sha256=KPMmCYrAn8unm48YD5YIfIQf4kViFct7hyqcfVzRnWQ,8348
+h11-0.16.0.dist-info/RECORD,,
+h11-0.16.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+h11-0.16.0.dist-info/licenses/LICENSE.txt,sha256=N9tbuFkm2yikJ6JYZ_ELEjIAOuob5pzLhRE4rbjm82E,1124
+h11-0.16.0.dist-info/top_level.txt,sha256=F7dC4jl3zeh8TGHEPaWJrMbeuoWbS379Gwdi-Yvdcis,4
+h11/__init__.py,sha256=iO1KzkSO42yZ6ffg-VMgbx_ZVTWGUY00nRYEWn-s3kY,1507
+h11/__pycache__/__init__.cpython-311.pyc,,
+h11/__pycache__/_abnf.cpython-311.pyc,,
+h11/__pycache__/_connection.cpython-311.pyc,,
+h11/__pycache__/_events.cpython-311.pyc,,
+h11/__pycache__/_headers.cpython-311.pyc,,
+h11/__pycache__/_readers.cpython-311.pyc,,
+h11/__pycache__/_receivebuffer.cpython-311.pyc,,
+h11/__pycache__/_state.cpython-311.pyc,,
+h11/__pycache__/_util.cpython-311.pyc,,
+h11/__pycache__/_version.cpython-311.pyc,,
+h11/__pycache__/_writers.cpython-311.pyc,,
+h11/_abnf.py,sha256=ybixr0xsupnkA6GFAyMubuXF6Tc1lb_hF890NgCsfNc,4815
+h11/_connection.py,sha256=k9YRVf6koZqbttBW36xSWaJpWdZwa-xQVU9AHEo9DuI,26863
+h11/_events.py,sha256=I97aXoal1Wu7dkL548BANBUCkOIbe-x5CioYA9IBY14,11792
+h11/_headers.py,sha256=P7D-lBNxHwdLZPLimmYwrPG-9ZkjElvvJZJdZAgSP-4,10412
+h11/_readers.py,sha256=a4RypORUCC3d0q_kxPuBIM7jTD8iLt5X91TH0FsduN4,8590
+h11/_receivebuffer.py,sha256=xrspsdsNgWFxRfQcTXxR8RrdjRXXTK0Io5cQYWpJ1Ws,5252
+h11/_state.py,sha256=_5LG_BGR8FCcFQeBPH-TMHgm_-B-EUcWCnQof_9XjFE,13231
+h11/_util.py,sha256=LWkkjXyJaFlAy6Lt39w73UStklFT5ovcvo0TkY7RYuk,4888
+h11/_version.py,sha256=GVSsbPSPDcOuF6ptfIiXnVJoaEm3ygXbMnqlr_Giahw,686
+h11/_writers.py,sha256=oFKm6PtjeHfbj4RLX7VB7KDc1gIY53gXG3_HR9ltmTA,5081
+h11/py.typed,sha256=sow9soTwP9T_gEAQSVh7Gb8855h04Nwmhs2We-JRgZM,7
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..1eb3c49d99559863120cfb8433fc8738fba43ba9
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (78.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/licenses/LICENSE.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/licenses/LICENSE.txt
new file mode 100644
index 0000000000000000000000000000000000000000..8f080eae848f759c9173bfc0c79506357ebe5090
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/licenses/LICENSE.txt
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Nathaniel J. Smith <njs@pobox.com> and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/top_level.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/top_level.txt
new file mode 100644
index 0000000000000000000000000000000000000000..0d24def711344ec6f4da2108f7d5c9261eb35f8b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11-0.16.0.dist-info/top_level.txt
@@ -0,0 +1 @@
+h11
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..989e92c3458681a6f0be72ae4105ea742750d328
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__init__.py
@@ -0,0 +1,62 @@
+# A highish-level implementation of the HTTP/1.1 wire protocol (RFC 7230),
+# containing no networking code at all, loosely modelled on hyper-h2's generic
+# implementation of HTTP/2 (and in particular the h2.connection.H2Connection
+# class). There's still a bunch of subtle details you need to get right if you
+# want to make this actually useful, because it doesn't implement all the
+# semantics to check that what you're asking to write to the wire is sensible,
+# but at least it gets you out of dealing with the wire itself.
+
+from h11._connection import Connection, NEED_DATA, PAUSED
+from h11._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from h11._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    ERROR,
+    IDLE,
+    MIGHT_SWITCH_PROTOCOL,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
+from h11._util import LocalProtocolError, ProtocolError, RemoteProtocolError
+from h11._version import __version__
+
+PRODUCT_ID = "python-h11/" + __version__
+
+
+__all__ = (
+    "Connection",
+    "NEED_DATA",
+    "PAUSED",
+    "ConnectionClosed",
+    "Data",
+    "EndOfMessage",
+    "Event",
+    "InformationalResponse",
+    "Request",
+    "Response",
+    "CLIENT",
+    "CLOSED",
+    "DONE",
+    "ERROR",
+    "IDLE",
+    "MUST_CLOSE",
+    "SEND_BODY",
+    "SEND_RESPONSE",
+    "SERVER",
+    "SWITCHED_PROTOCOL",
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1f988133aade09c6fa89ebd2f7299fb62a3c13ce
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_abnf.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_abnf.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a5454bba389b6446e944a7bfb6793479ac26063e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_abnf.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_connection.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_connection.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..103bfc221aea01b3a624e0d6ad0087fee3091291
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_connection.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_events.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_events.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..12762170b29ef3e3099417840252c9628163a18f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_events.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_headers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_headers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0f268e0baf412e902dbeaa4cfeab8379e37c9b4b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_headers.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_readers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_readers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e5a24f884821c103d43520eacfc862e81b62043
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_readers.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_receivebuffer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_receivebuffer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ef9cc0b3ace426695bc2bd863a1b1aec1201cf1e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_receivebuffer.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_state.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_state.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b46fd1f2e50499572574e20ed2faadbbfe36d3f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_state.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_util.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_util.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..eedadfc0b47aa8a7ee63ca3f235341e526b1c475
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_util.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_version.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_version.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..46ab74d6b7d831f55d31ed2d64a951f78fb8667c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_version.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_writers.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_writers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5b31978c55c287fa45902f537efd92bba276a725
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/__pycache__/_writers.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_abnf.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_abnf.py
new file mode 100644
index 0000000000000000000000000000000000000000..933587fba22290d7eb7df4c88e12f1e61702b8ce
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_abnf.py
@@ -0,0 +1,132 @@
+# We use native strings for all the re patterns, to take advantage of string
+# formatting, and then convert to bytestrings when compiling the final re
+# objects.
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#whitespace
+#  OWS            = *( SP / HTAB )
+#                 ; optional whitespace
+OWS = r"[ \t]*"
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#rule.token.separators
+#   token          = 1*tchar
+#
+#   tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+#                  / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+#                  / DIGIT / ALPHA
+#                  ; any VCHAR, except delimiters
+token = r"[-!#$%&'*+.^_`|~0-9a-zA-Z]+"
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#header.fields
+#  field-name     = token
+field_name = token
+
+# The standard says:
+#
+#  field-value    = *( field-content / obs-fold )
+#  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+#  field-vchar    = VCHAR / obs-text
+#  obs-fold       = CRLF 1*( SP / HTAB )
+#                 ; obsolete line folding
+#                 ; see Section 3.2.4
+#
+# https://tools.ietf.org/html/rfc5234#appendix-B.1
+#
+#   VCHAR          =  %x21-7E
+#                  ; visible (printing) characters
+#
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#rule.quoted-string
+#   obs-text       = %x80-FF
+#
+# However, the standard definition of field-content is WRONG! It disallows
+# fields containing a single visible character surrounded by whitespace,
+# e.g. "foo a bar".
+#
+# See: https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4189
+#
+# So our definition of field_content attempts to fix it up...
+#
+# Also, we allow lots of control characters, because apparently people assume
+# that they're legal in practice (e.g., google analytics makes cookies with
+# \x01 in them!):
+#   https://github.com/python-hyper/h11/issues/57
+# We still don't allow NUL or whitespace, because those are often treated as
+# meta-characters and letting them through can lead to nasty issues like SSRF.
+vchar = r"[\x21-\x7e]"
+vchar_or_obs_text = r"[^\x00\s]"
+field_vchar = vchar_or_obs_text
+field_content = r"{field_vchar}+(?:[ \t]+{field_vchar}+)*".format(**globals())
+
+# We handle obs-fold at a different level, and our fixed-up field_content
+# already grows to swallow the whole value, so ? instead of *
+field_value = r"({field_content})?".format(**globals())
+
+#  header-field   = field-name ":" OWS field-value OWS
+header_field = (
+    r"(?P<field_name>{field_name})"
+    r":"
+    r"{OWS}"
+    r"(?P<field_value>{field_value})"
+    r"{OWS}".format(**globals())
+)
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#request.line
+#
+#   request-line   = method SP request-target SP HTTP-version CRLF
+#   method         = token
+#   HTTP-version   = HTTP-name "/" DIGIT "." DIGIT
+#   HTTP-name      = %x48.54.54.50 ; "HTTP", case-sensitive
+#
+# request-target is complicated (see RFC 7230 sec 5.3) -- could be path, full
+# URL, host+port (for connect), or even "*", but in any case we are guaranteed
+# that it contists of the visible printing characters.
+method = token
+request_target = r"{vchar}+".format(**globals())
+http_version = r"HTTP/(?P<http_version>[0-9]\.[0-9])"
+request_line = (
+    r"(?P<method>{method})"
+    r" "
+    r"(?P<target>{request_target})"
+    r" "
+    r"{http_version}".format(**globals())
+)
+
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#status.line
+#
+#   status-line = HTTP-version SP status-code SP reason-phrase CRLF
+#   status-code    = 3DIGIT
+#   reason-phrase  = *( HTAB / SP / VCHAR / obs-text )
+status_code = r"[0-9]{3}"
+reason_phrase = r"([ \t]|{vchar_or_obs_text})*".format(**globals())
+status_line = (
+    r"{http_version}"
+    r" "
+    r"(?P<status_code>{status_code})"
+    # However, there are apparently a few too many servers out there that just
+    # leave out the reason phrase:
+    #   https://github.com/scrapy/scrapy/issues/345#issuecomment-281756036
+    #   https://github.com/seanmonstar/httparse/issues/29
+    # so make it optional. ?: is a non-capturing group.
+    r"(?: (?P<reason>{reason_phrase}))?".format(**globals())
+)
+
+HEXDIG = r"[0-9A-Fa-f]"
+# Actually
+#
+#      chunk-size     = 1*HEXDIG
+#
+# but we impose an upper-limit to avoid ridiculosity. len(str(2**64)) == 20
+chunk_size = r"({HEXDIG}){{1,20}}".format(**globals())
+# Actually
+#
+#     chunk-ext      = *( ";" chunk-ext-name [ "=" chunk-ext-val ] )
+#
+# but we aren't parsing the things so we don't really care.
+chunk_ext = r";.*"
+chunk_header = (
+    r"(?P<chunk_size>{chunk_size})"
+    r"(?P<chunk_ext>{chunk_ext})?"
+    r"{OWS}\r\n".format(
+        **globals()
+    )  # Even though the specification does not allow for extra whitespaces,
+    # we are lenient with trailing whitespaces because some servers on the wild use it.
+)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_connection.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..e37d82a82a882c072cb938a90eb4486b51cdad99
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_connection.py
@@ -0,0 +1,659 @@
+# This contains the main Connection class. Everything in h11 revolves around
+# this.
+from typing import (
+    Any,
+    Callable,
+    cast,
+    Dict,
+    List,
+    Optional,
+    overload,
+    Tuple,
+    Type,
+    Union,
+)
+
+from ._events import (
+    ConnectionClosed,
+    Data,
+    EndOfMessage,
+    Event,
+    InformationalResponse,
+    Request,
+    Response,
+)
+from ._headers import get_comma_header, has_expect_100_continue, set_comma_header
+from ._readers import READERS, ReadersType
+from ._receivebuffer import ReceiveBuffer
+from ._state import (
+    _SWITCH_CONNECT,
+    _SWITCH_UPGRADE,
+    CLIENT,
+    ConnectionState,
+    DONE,
+    ERROR,
+    MIGHT_SWITCH_PROTOCOL,
+    SEND_BODY,
+    SERVER,
+    SWITCHED_PROTOCOL,
+)
+from ._util import (  # Import the internal things we need
+    LocalProtocolError,
+    RemoteProtocolError,
+    Sentinel,
+)
+from ._writers import WRITERS, WritersType
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = ["Connection", "NEED_DATA", "PAUSED"]
+
+
+class NEED_DATA(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class PAUSED(Sentinel, metaclass=Sentinel):
+    pass
+
+
+# If we ever have this much buffered without it making a complete parseable
+# event, we error out. The only time we really buffer is when reading the
+# request/response line + headers together, so this is effectively the limit on
+# the size of that.
+#
+# Some precedents for defaults:
+# - node.js: 80 * 1024
+# - tomcat: 8 * 1024
+# - IIS: 16 * 1024
+# - Apache: <8 KiB per line>
+DEFAULT_MAX_INCOMPLETE_EVENT_SIZE = 16 * 1024
+
+
+# RFC 7230's rules for connection lifecycles:
+# - If either side says they want to close the connection, then the connection
+#   must close.
+# - HTTP/1.1 defaults to keep-alive unless someone says Connection: close
+# - HTTP/1.0 defaults to close unless both sides say Connection: keep-alive
+#   (and even this is a mess -- e.g. if you're implementing a proxy then
+#   sending Connection: keep-alive is forbidden).
+#
+# We simplify life by simply not supporting keep-alive with HTTP/1.0 peers. So
+# our rule is:
+# - If someone says Connection: close, we will close
+# - If someone uses HTTP/1.0, we will close.
+def _keep_alive(event: Union[Request, Response]) -> bool:
+    connection = get_comma_header(event.headers, b"connection")
+    if b"close" in connection:
+        return False
+    if getattr(event, "http_version", b"1.1") < b"1.1":
+        return False
+    return True
+
+
+def _body_framing(
+    request_method: bytes, event: Union[Request, Response]
+) -> Tuple[str, Union[Tuple[()], Tuple[int]]]:
+    # Called when we enter SEND_BODY to figure out framing information for
+    # this body.
+    #
+    # These are the only two events that can trigger a SEND_BODY state:
+    assert type(event) in (Request, Response)
+    # Returns one of:
+    #
+    #    ("content-length", count)
+    #    ("chunked", ())
+    #    ("http/1.0", ())
+    #
+    # which are (lookup key, *args) for constructing body reader/writer
+    # objects.
+    #
+    # Reference: https://tools.ietf.org/html/rfc7230#section-3.3.3
+    #
+    # Step 1: some responses always have an empty body, regardless of what the
+    # headers say.
+    if type(event) is Response:
+        if (
+            event.status_code in (204, 304)
+            or request_method == b"HEAD"
+            or (request_method == b"CONNECT" and 200 <= event.status_code < 300)
+        ):
+            return ("content-length", (0,))
+        # Section 3.3.3 also lists another case -- responses with status_code
+        # < 200. For us these are InformationalResponses, not Responses, so
+        # they can't get into this function in the first place.
+        assert event.status_code >= 200
+
+    # Step 2: check for Transfer-Encoding (T-E beats C-L):
+    transfer_encodings = get_comma_header(event.headers, b"transfer-encoding")
+    if transfer_encodings:
+        assert transfer_encodings == [b"chunked"]
+        return ("chunked", ())
+
+    # Step 3: check for Content-Length
+    content_lengths = get_comma_header(event.headers, b"content-length")
+    if content_lengths:
+        return ("content-length", (int(content_lengths[0]),))
+
+    # Step 4: no applicable headers; fallback/default depends on type
+    if type(event) is Request:
+        return ("content-length", (0,))
+    else:
+        return ("http/1.0", ())
+
+
+################################################################
+#
+# The main Connection class
+#
+################################################################
+
+
+class Connection:
+    """An object encapsulating the state of an HTTP connection.
+
+    Args:
+        our_role: If you're implementing a client, pass :data:`h11.CLIENT`. If
+            you're implementing a server, pass :data:`h11.SERVER`.
+
+        max_incomplete_event_size (int):
+            The maximum number of bytes we're willing to buffer of an
+            incomplete event. In practice this mostly sets a limit on the
+            maximum size of the request/response line + headers. If this is
+            exceeded, then :meth:`next_event` will raise
+            :exc:`RemoteProtocolError`.
+
+    """
+
+    def __init__(
+        self,
+        our_role: Type[Sentinel],
+        max_incomplete_event_size: int = DEFAULT_MAX_INCOMPLETE_EVENT_SIZE,
+    ) -> None:
+        self._max_incomplete_event_size = max_incomplete_event_size
+        # State and role tracking
+        if our_role not in (CLIENT, SERVER):
+            raise ValueError(f"expected CLIENT or SERVER, not {our_role!r}")
+        self.our_role = our_role
+        self.their_role: Type[Sentinel]
+        if our_role is CLIENT:
+            self.their_role = SERVER
+        else:
+            self.their_role = CLIENT
+        self._cstate = ConnectionState()
+
+        # Callables for converting data->events or vice-versa given the
+        # current state
+        self._writer = self._get_io_object(self.our_role, None, WRITERS)
+        self._reader = self._get_io_object(self.their_role, None, READERS)
+
+        # Holds any unprocessed received data
+        self._receive_buffer = ReceiveBuffer()
+        # If this is true, then it indicates that the incoming connection was
+        # closed *after* the end of whatever's in self._receive_buffer:
+        self._receive_buffer_closed = False
+
+        # Extra bits of state that don't fit into the state machine.
+        #
+        # These two are only used to interpret framing headers for figuring
+        # out how to read/write response bodies. their_http_version is also
+        # made available as a convenient public API.
+        self.their_http_version: Optional[bytes] = None
+        self._request_method: Optional[bytes] = None
+        # This is pure flow-control and doesn't at all affect the set of legal
+        # transitions, so no need to bother ConnectionState with it:
+        self.client_is_waiting_for_100_continue = False
+
+    @property
+    def states(self) -> Dict[Type[Sentinel], Type[Sentinel]]:
+        """A dictionary like::
+
+           {CLIENT: <client state>, SERVER: <server state>}
+
+        See :ref:`state-machine` for details.
+
+        """
+        return dict(self._cstate.states)
+
+    @property
+    def our_state(self) -> Type[Sentinel]:
+        """The current state of whichever role we are playing. See
+        :ref:`state-machine` for details.
+        """
+        return self._cstate.states[self.our_role]
+
+    @property
+    def their_state(self) -> Type[Sentinel]:
+        """The current state of whichever role we are NOT playing. See
+        :ref:`state-machine` for details.
+        """
+        return self._cstate.states[self.their_role]
+
+    @property
+    def they_are_waiting_for_100_continue(self) -> bool:
+        return self.their_role is CLIENT and self.client_is_waiting_for_100_continue
+
+    def start_next_cycle(self) -> None:
+        """Attempt to reset our connection state for a new request/response
+        cycle.
+
+        If both client and server are in :data:`DONE` state, then resets them
+        both to :data:`IDLE` state in preparation for a new request/response
+        cycle on this same connection. Otherwise, raises a
+        :exc:`LocalProtocolError`.
+
+        See :ref:`keepalive-and-pipelining`.
+
+        """
+        old_states = dict(self._cstate.states)
+        self._cstate.start_next_cycle()
+        self._request_method = None
+        # self.their_http_version gets left alone, since it presumably lasts
+        # beyond a single request/response cycle
+        assert not self.client_is_waiting_for_100_continue
+        self._respond_to_state_changes(old_states)
+
+    def _process_error(self, role: Type[Sentinel]) -> None:
+        old_states = dict(self._cstate.states)
+        self._cstate.process_error(role)
+        self._respond_to_state_changes(old_states)
+
+    def _server_switch_event(self, event: Event) -> Optional[Type[Sentinel]]:
+        if type(event) is InformationalResponse and event.status_code == 101:
+            return _SWITCH_UPGRADE
+        if type(event) is Response:
+            if (
+                _SWITCH_CONNECT in self._cstate.pending_switch_proposals
+                and 200 <= event.status_code < 300
+            ):
+                return _SWITCH_CONNECT
+        return None
+
+    # All events go through here
+    def _process_event(self, role: Type[Sentinel], event: Event) -> None:
+        # First, pass the event through the state machine to make sure it
+        # succeeds.
+        old_states = dict(self._cstate.states)
+        if role is CLIENT and type(event) is Request:
+            if event.method == b"CONNECT":
+                self._cstate.process_client_switch_proposal(_SWITCH_CONNECT)
+            if get_comma_header(event.headers, b"upgrade"):
+                self._cstate.process_client_switch_proposal(_SWITCH_UPGRADE)
+        server_switch_event = None
+        if role is SERVER:
+            server_switch_event = self._server_switch_event(event)
+        self._cstate.process_event(role, type(event), server_switch_event)
+
+        # Then perform the updates triggered by it.
+
+        if type(event) is Request:
+            self._request_method = event.method
+
+        if role is self.their_role and type(event) in (
+            Request,
+            Response,
+            InformationalResponse,
+        ):
+            event = cast(Union[Request, Response, InformationalResponse], event)
+            self.their_http_version = event.http_version
+
+        # Keep alive handling
+        #
+        # RFC 7230 doesn't really say what one should do if Connection: close
+        # shows up on a 1xx InformationalResponse. I think the idea is that
+        # this is not supposed to happen. In any case, if it does happen, we
+        # ignore it.
+        if type(event) in (Request, Response) and not _keep_alive(
+            cast(Union[Request, Response], event)
+        ):
+            self._cstate.process_keep_alive_disabled()
+
+        # 100-continue
+        if type(event) is Request and has_expect_100_continue(event):
+            self.client_is_waiting_for_100_continue = True
+        if type(event) in (InformationalResponse, Response):
+            self.client_is_waiting_for_100_continue = False
+        if role is CLIENT and type(event) in (Data, EndOfMessage):
+            self.client_is_waiting_for_100_continue = False
+
+        self._respond_to_state_changes(old_states, event)
+
+    def _get_io_object(
+        self,
+        role: Type[Sentinel],
+        event: Optional[Event],
+        io_dict: Union[ReadersType, WritersType],
+    ) -> Optional[Callable[..., Any]]:
+        # event may be None; it's only used when entering SEND_BODY
+        state = self._cstate.states[role]
+        if state is SEND_BODY:
+            # Special case: the io_dict has a dict of reader/writer factories
+            # that depend on the request/response framing.
+            framing_type, args = _body_framing(
+                cast(bytes, self._request_method), cast(Union[Request, Response], event)
+            )
+            return io_dict[SEND_BODY][framing_type](*args)  # type: ignore[index]
+        else:
+            # General case: the io_dict just has the appropriate reader/writer
+            # for this state
+            return io_dict.get((role, state))  # type: ignore[return-value]
+
+    # This must be called after any action that might have caused
+    # self._cstate.states to change.
+    def _respond_to_state_changes(
+        self,
+        old_states: Dict[Type[Sentinel], Type[Sentinel]],
+        event: Optional[Event] = None,
+    ) -> None:
+        # Update reader/writer
+        if self.our_state != old_states[self.our_role]:
+            self._writer = self._get_io_object(self.our_role, event, WRITERS)
+        if self.their_state != old_states[self.their_role]:
+            self._reader = self._get_io_object(self.their_role, event, READERS)
+
+    @property
+    def trailing_data(self) -> Tuple[bytes, bool]:
+        """Data that has been received, but not yet processed, represented as
+        a tuple with two elements, where the first is a byte-string containing
+        the unprocessed data itself, and the second is a bool that is True if
+        the receive connection was closed.
+
+        See :ref:`switching-protocols` for discussion of why you'd want this.
+        """
+        return (bytes(self._receive_buffer), self._receive_buffer_closed)
+
+    def receive_data(self, data: bytes) -> None:
+        """Add data to our internal receive buffer.
+
+        This does not actually do any processing on the data, just stores
+        it. To trigger processing, you have to call :meth:`next_event`.
+
+        Args:
+            data (:term:`bytes-like object`):
+                The new data that was just received.
+
+                Special case: If *data* is an empty byte-string like ``b""``,
+                then this indicates that the remote side has closed the
+                connection (end of file). Normally this is convenient, because
+                standard Python APIs like :meth:`file.read` or
+                :meth:`socket.recv` use ``b""`` to indicate end-of-file, while
+                other failures to read are indicated using other mechanisms
+                like raising :exc:`TimeoutError`. When using such an API you
+                can just blindly pass through whatever you get from ``read``
+                to :meth:`receive_data`, and everything will work.
+
+                But, if you have an API where reading an empty string is a
+                valid non-EOF condition, then you need to be aware of this and
+                make sure to check for such strings and avoid passing them to
+                :meth:`receive_data`.
+
+        Returns:
+            Nothing, but after calling this you should call :meth:`next_event`
+            to parse the newly received data.
+
+        Raises:
+            RuntimeError:
+                Raised if you pass an empty *data*, indicating EOF, and then
+                pass a non-empty *data*, indicating more data that somehow
+                arrived after the EOF.
+
+                (Calling ``receive_data(b"")`` multiple times is fine,
+                and equivalent to calling it once.)
+
+        """
+        if data:
+            if self._receive_buffer_closed:
+                raise RuntimeError("received close, then received more data?")
+            self._receive_buffer += data
+        else:
+            self._receive_buffer_closed = True
+
+    def _extract_next_receive_event(
+        self,
+    ) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
+        state = self.their_state
+        # We don't pause immediately when they enter DONE, because even in
+        # DONE state we can still process a ConnectionClosed() event. But
+        # if we have data in our buffer, then we definitely aren't getting
+        # a ConnectionClosed() immediately and we need to pause.
+        if state is DONE and self._receive_buffer:
+            return PAUSED
+        if state is MIGHT_SWITCH_PROTOCOL or state is SWITCHED_PROTOCOL:
+            return PAUSED
+        assert self._reader is not None
+        event = self._reader(self._receive_buffer)
+        if event is None:
+            if not self._receive_buffer and self._receive_buffer_closed:
+                # In some unusual cases (basically just HTTP/1.0 bodies), EOF
+                # triggers an actual protocol event; in that case, we want to
+                # return that event, and then the state will change and we'll
+                # get called again to generate the actual ConnectionClosed().
+                if hasattr(self._reader, "read_eof"):
+                    event = self._reader.read_eof()
+                else:
+                    event = ConnectionClosed()
+        if event is None:
+            event = NEED_DATA
+        return event  # type: ignore[no-any-return]
+
+    def next_event(self) -> Union[Event, Type[NEED_DATA], Type[PAUSED]]:
+        """Parse the next event out of our receive buffer, update our internal
+        state, and return it.
+
+        This is a mutating operation -- think of it like calling :func:`next`
+        on an iterator.
+
+        Returns:
+            : One of three things:
+
+            1) An event object -- see :ref:`events`.
+
+            2) The special constant :data:`NEED_DATA`, which indicates that
+               you need to read more data from your socket and pass it to
+               :meth:`receive_data` before this method will be able to return
+               any more events.
+
+            3) The special constant :data:`PAUSED`, which indicates that we
+               are not in a state where we can process incoming data (usually
+               because the peer has finished their part of the current
+               request/response cycle, and you have not yet called
+               :meth:`start_next_cycle`). See :ref:`flow-control` for details.
+
+        Raises:
+            RemoteProtocolError:
+                The peer has misbehaved. You should close the connection
+                (possibly after sending some kind of 4xx response).
+
+        Once this method returns :class:`ConnectionClosed` once, then all
+        subsequent calls will also return :class:`ConnectionClosed`.
+
+        If this method raises any exception besides :exc:`RemoteProtocolError`
+        then that's a bug -- if it happens please file a bug report!
+
+        If this method raises any exception then it also sets
+        :attr:`Connection.their_state` to :data:`ERROR` -- see
+        :ref:`error-handling` for discussion.
+
+        """
+
+        if self.their_state is ERROR:
+            raise RemoteProtocolError("Can't receive data when peer state is ERROR")
+        try:
+            event = self._extract_next_receive_event()
+            if event not in [NEED_DATA, PAUSED]:
+                self._process_event(self.their_role, cast(Event, event))
+            if event is NEED_DATA:
+                if len(self._receive_buffer) > self._max_incomplete_event_size:
+                    # 431 is "Request header fields too large" which is pretty
+                    # much the only situation where we can get here
+                    raise RemoteProtocolError(
+                        "Receive buffer too long", error_status_hint=431
+                    )
+                if self._receive_buffer_closed:
+                    # We're still trying to complete some event, but that's
+                    # never going to happen because no more data is coming
+                    raise RemoteProtocolError("peer unexpectedly closed connection")
+            return event
+        except BaseException as exc:
+            self._process_error(self.their_role)
+            if isinstance(exc, LocalProtocolError):
+                exc._reraise_as_remote_protocol_error()
+            else:
+                raise
+
+    @overload
+    def send(self, event: ConnectionClosed) -> None:
+        ...
+
+    @overload
+    def send(
+        self, event: Union[Request, InformationalResponse, Response, Data, EndOfMessage]
+    ) -> bytes:
+        ...
+
+    @overload
+    def send(self, event: Event) -> Optional[bytes]:
+        ...
+
+    def send(self, event: Event) -> Optional[bytes]:
+        """Convert a high-level event into bytes that can be sent to the peer,
+        while updating our internal state machine.
+
+        Args:
+            event: The :ref:`event <events>` to send.
+
+        Returns:
+            If ``type(event) is ConnectionClosed``, then returns
+            ``None``. Otherwise, returns a :term:`bytes-like object`.
+
+        Raises:
+            LocalProtocolError:
+                Sending this event at this time would violate our
+                understanding of the HTTP/1.1 protocol.
+
+        If this method raises any exception then it also sets
+        :attr:`Connection.our_state` to :data:`ERROR` -- see
+        :ref:`error-handling` for discussion.
+
+        """
+        data_list = self.send_with_data_passthrough(event)
+        if data_list is None:
+            return None
+        else:
+            return b"".join(data_list)
+
+    def send_with_data_passthrough(self, event: Event) -> Optional[List[bytes]]:
+        """Identical to :meth:`send`, except that in situations where
+        :meth:`send` returns a single :term:`bytes-like object`, this instead
+        returns a list of them -- and when sending a :class:`Data` event, this
+        list is guaranteed to contain the exact object you passed in as
+        :attr:`Data.data`. See :ref:`sendfile` for discussion.
+
+        """
+        if self.our_state is ERROR:
+            raise LocalProtocolError("Can't send data when our state is ERROR")
+        try:
+            if type(event) is Response:
+                event = self._clean_up_response_headers_for_sending(event)
+            # We want to call _process_event before calling the writer,
+            # because if someone tries to do something invalid then this will
+            # give a sensible error message, while our writers all just assume
+            # they will only receive valid events. But, _process_event might
+            # change self._writer. So we have to do a little dance:
+            writer = self._writer
+            self._process_event(self.our_role, event)
+            if type(event) is ConnectionClosed:
+                return None
+            else:
+                # In any situation where writer is None, process_event should
+                # have raised ProtocolError
+                assert writer is not None
+                data_list: List[bytes] = []
+                writer(event, data_list.append)
+                return data_list
+        except:
+            self._process_error(self.our_role)
+            raise
+
+    def send_failed(self) -> None:
+        """Notify the state machine that we failed to send the data it gave
+        us.
+
+        This causes :attr:`Connection.our_state` to immediately become
+        :data:`ERROR` -- see :ref:`error-handling` for discussion.
+
+        """
+        self._process_error(self.our_role)
+
+    # When sending a Response, we take responsibility for a few things:
+    #
+    # - Sometimes you MUST set Connection: close. We take care of those
+    #   times. (You can also set it yourself if you want, and if you do then
+    #   we'll respect that and close the connection at the right time. But you
+    #   don't have to worry about that unless you want to.)
+    #
+    # - The user has to set Content-Length if they want it. Otherwise, for
+    #   responses that have bodies (e.g. not HEAD), then we will automatically
+    #   select the right mechanism for streaming a body of unknown length,
+    #   which depends on depending on the peer's HTTP version.
+    #
+    # This function's *only* responsibility is making sure headers are set up
+    # right -- everything downstream just looks at the headers. There are no
+    # side channels.
+    def _clean_up_response_headers_for_sending(self, response: Response) -> Response:
+        assert type(response) is Response
+
+        headers = response.headers
+        need_close = False
+
+        # HEAD requests need some special handling: they always act like they
+        # have Content-Length: 0, and that's how _body_framing treats
+        # them. But their headers are supposed to match what we would send if
+        # the request was a GET. (Technically there is one deviation allowed:
+        # we're allowed to leave out the framing headers -- see
+        # https://tools.ietf.org/html/rfc7231#section-4.3.2 . But it's just as
+        # easy to get them right.)
+        method_for_choosing_headers = cast(bytes, self._request_method)
+        if method_for_choosing_headers == b"HEAD":
+            method_for_choosing_headers = b"GET"
+        framing_type, _ = _body_framing(method_for_choosing_headers, response)
+        if framing_type in ("chunked", "http/1.0"):
+            # This response has a body of unknown length.
+            # If our peer is HTTP/1.1, we use Transfer-Encoding: chunked
+            # If our peer is HTTP/1.0, we use no framing headers, and close the
+            # connection afterwards.
+            #
+            # Make sure to clear Content-Length (in principle user could have
+            # set both and then we ignored Content-Length b/c
+            # Transfer-Encoding overwrote it -- this would be naughty of them,
+            # but the HTTP spec says that if our peer does this then we have
+            # to fix it instead of erroring out, so we'll accord the user the
+            # same respect).
+            headers = set_comma_header(headers, b"content-length", [])
+            if self.their_http_version is None or self.their_http_version < b"1.1":
+                # Either we never got a valid request and are sending back an
+                # error (their_http_version is None), so we assume the worst;
+                # or else we did get a valid HTTP/1.0 request, so we know that
+                # they don't understand chunked encoding.
+                headers = set_comma_header(headers, b"transfer-encoding", [])
+                # This is actually redundant ATM, since currently we
+                # unconditionally disable keep-alive when talking to HTTP/1.0
+                # peers. But let's be defensive just in case we add
+                # Connection: keep-alive support later:
+                if self._request_method != b"HEAD":
+                    need_close = True
+            else:
+                headers = set_comma_header(headers, b"transfer-encoding", [b"chunked"])
+
+        if not self._cstate.keep_alive or need_close:
+            # Make sure Connection: close is set
+            connection = set(get_comma_header(headers, b"connection"))
+            connection.discard(b"keep-alive")
+            connection.add(b"close")
+            headers = set_comma_header(headers, b"connection", sorted(connection))
+
+        return Response(
+            headers=headers,
+            status_code=response.status_code,
+            http_version=response.http_version,
+            reason=response.reason,
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_events.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_events.py
new file mode 100644
index 0000000000000000000000000000000000000000..ca1c3adbde2c4e7710482a18e3471f91f1da610e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_events.py
@@ -0,0 +1,369 @@
+# High level events that make up HTTP/1.1 conversations. Loosely inspired by
+# the corresponding events in hyper-h2:
+#
+#     http://python-hyper.org/h2/en/stable/api.html#events
+#
+# Don't subclass these. Stuff will break.
+
+import re
+from abc import ABC
+from dataclasses import dataclass
+from typing import List, Tuple, Union
+
+from ._abnf import method, request_target
+from ._headers import Headers, normalize_and_validate
+from ._util import bytesify, LocalProtocolError, validate
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = [
+    "Event",
+    "Request",
+    "InformationalResponse",
+    "Response",
+    "Data",
+    "EndOfMessage",
+    "ConnectionClosed",
+]
+
+method_re = re.compile(method.encode("ascii"))
+request_target_re = re.compile(request_target.encode("ascii"))
+
+
+class Event(ABC):
+    """
+    Base class for h11 events.
+    """
+
+    __slots__ = ()
+
+
+@dataclass(init=False, frozen=True)
+class Request(Event):
+    """The beginning of an HTTP request.
+
+    Fields:
+
+    .. attribute:: method
+
+       An HTTP method, e.g. ``b"GET"`` or ``b"POST"``. Always a byte
+       string. :term:`Bytes-like objects <bytes-like object>` and native
+       strings containing only ascii characters will be automatically
+       converted to byte strings.
+
+    .. attribute:: target
+
+       The target of an HTTP request, e.g. ``b"/index.html"``, or one of the
+       more exotic formats described in `RFC 7320, section 5.3
+       <https://tools.ietf.org/html/rfc7230#section-5.3>`_. Always a byte
+       string. :term:`Bytes-like objects <bytes-like object>` and native
+       strings containing only ascii characters will be automatically
+       converted to byte strings.
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    """
+
+    __slots__ = ("method", "headers", "target", "http_version")
+
+    method: bytes
+    headers: Headers
+    target: bytes
+    http_version: bytes
+
+    def __init__(
+        self,
+        *,
+        method: Union[bytes, str],
+        headers: Union[Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]]],
+        target: Union[bytes, str],
+        http_version: Union[bytes, str] = b"1.1",
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if isinstance(headers, Headers):
+            object.__setattr__(self, "headers", headers)
+        else:
+            object.__setattr__(
+                self, "headers", normalize_and_validate(headers, _parsed=_parsed)
+            )
+        if not _parsed:
+            object.__setattr__(self, "method", bytesify(method))
+            object.__setattr__(self, "target", bytesify(target))
+            object.__setattr__(self, "http_version", bytesify(http_version))
+        else:
+            object.__setattr__(self, "method", method)
+            object.__setattr__(self, "target", target)
+            object.__setattr__(self, "http_version", http_version)
+
+        # "A server MUST respond with a 400 (Bad Request) status code to any
+        # HTTP/1.1 request message that lacks a Host header field and to any
+        # request message that contains more than one Host header field or a
+        # Host header field with an invalid field-value."
+        # -- https://tools.ietf.org/html/rfc7230#section-5.4
+        host_count = 0
+        for name, value in self.headers:
+            if name == b"host":
+                host_count += 1
+        if self.http_version == b"1.1" and host_count == 0:
+            raise LocalProtocolError("Missing mandatory Host: header")
+        if host_count > 1:
+            raise LocalProtocolError("Found multiple Host: headers")
+
+        validate(method_re, self.method, "Illegal method characters")
+        validate(request_target_re, self.target, "Illegal target characters")
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(init=False, frozen=True)
+class _ResponseBase(Event):
+    __slots__ = ("headers", "http_version", "reason", "status_code")
+
+    headers: Headers
+    http_version: bytes
+    reason: bytes
+    status_code: int
+
+    def __init__(
+        self,
+        *,
+        headers: Union[Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]]],
+        status_code: int,
+        http_version: Union[bytes, str] = b"1.1",
+        reason: Union[bytes, str] = b"",
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if isinstance(headers, Headers):
+            object.__setattr__(self, "headers", headers)
+        else:
+            object.__setattr__(
+                self, "headers", normalize_and_validate(headers, _parsed=_parsed)
+            )
+        if not _parsed:
+            object.__setattr__(self, "reason", bytesify(reason))
+            object.__setattr__(self, "http_version", bytesify(http_version))
+            if not isinstance(status_code, int):
+                raise LocalProtocolError("status code must be integer")
+            # Because IntEnum objects are instances of int, but aren't
+            # duck-compatible (sigh), see gh-72.
+            object.__setattr__(self, "status_code", int(status_code))
+        else:
+            object.__setattr__(self, "reason", reason)
+            object.__setattr__(self, "http_version", http_version)
+            object.__setattr__(self, "status_code", status_code)
+
+        self.__post_init__()
+
+    def __post_init__(self) -> None:
+        pass
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(init=False, frozen=True)
+class InformationalResponse(_ResponseBase):
+    """An HTTP informational response.
+
+    Fields:
+
+    .. attribute:: status_code
+
+       The status code of this response, as an integer. For an
+       :class:`InformationalResponse`, this is always in the range [100,
+       200).
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for
+       details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    .. attribute:: reason
+
+       The reason phrase of this response, as a byte string. For example:
+       ``b"OK"``, or ``b"Not Found"``.
+
+    """
+
+    def __post_init__(self) -> None:
+        if not (100 <= self.status_code < 200):
+            raise LocalProtocolError(
+                "InformationalResponse status_code should be in range "
+                "[100, 200), not {}".format(self.status_code)
+            )
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(init=False, frozen=True)
+class Response(_ResponseBase):
+    """The beginning of an HTTP response.
+
+    Fields:
+
+    .. attribute:: status_code
+
+       The status code of this response, as an integer. For an
+       :class:`Response`, this is always in the range [200,
+       1000).
+
+    .. attribute:: headers
+
+       Request headers, represented as a list of (name, value) pairs. See
+       :ref:`the header normalization rules <headers-format>` for details.
+
+    .. attribute:: http_version
+
+       The HTTP protocol version, represented as a byte string like
+       ``b"1.1"``. See :ref:`the HTTP version normalization rules
+       <http_version-format>` for details.
+
+    .. attribute:: reason
+
+       The reason phrase of this response, as a byte string. For example:
+       ``b"OK"``, or ``b"Not Found"``.
+
+    """
+
+    def __post_init__(self) -> None:
+        if not (200 <= self.status_code < 1000):
+            raise LocalProtocolError(
+                "Response status_code should be in range [200, 1000), not {}".format(
+                    self.status_code
+                )
+            )
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(init=False, frozen=True)
+class Data(Event):
+    """Part of an HTTP message body.
+
+    Fields:
+
+    .. attribute:: data
+
+       A :term:`bytes-like object` containing part of a message body. Or, if
+       using the ``combine=False`` argument to :meth:`Connection.send`, then
+       any object that your socket writing code knows what to do with, and for
+       which calling :func:`len` returns the number of bytes that will be
+       written -- see :ref:`sendfile` for details.
+
+    .. attribute:: chunk_start
+
+       A marker that indicates whether this data object is from the start of a
+       chunked transfer encoding chunk. This field is ignored when when a Data
+       event is provided to :meth:`Connection.send`: it is only valid on
+       events emitted from :meth:`Connection.next_event`. You probably
+       shouldn't use this attribute at all; see
+       :ref:`chunk-delimiters-are-bad` for details.
+
+    .. attribute:: chunk_end
+
+       A marker that indicates whether this data object is the last for a
+       given chunked transfer encoding chunk. This field is ignored when when
+       a Data event is provided to :meth:`Connection.send`: it is only valid
+       on events emitted from :meth:`Connection.next_event`. You probably
+       shouldn't use this attribute at all; see
+       :ref:`chunk-delimiters-are-bad` for details.
+
+    """
+
+    __slots__ = ("data", "chunk_start", "chunk_end")
+
+    data: bytes
+    chunk_start: bool
+    chunk_end: bool
+
+    def __init__(
+        self, data: bytes, chunk_start: bool = False, chunk_end: bool = False
+    ) -> None:
+        object.__setattr__(self, "data", data)
+        object.__setattr__(self, "chunk_start", chunk_start)
+        object.__setattr__(self, "chunk_end", chunk_end)
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+# XX FIXME: "A recipient MUST ignore (or consider as an error) any fields that
+# are forbidden to be sent in a trailer, since processing them as if they were
+# present in the header section might bypass external security filters."
+# https://svn.tools.ietf.org/svn/wg/httpbis/specs/rfc7230.html#chunked.trailer.part
+# Unfortunately, the list of forbidden fields is long and vague :-/
+@dataclass(init=False, frozen=True)
+class EndOfMessage(Event):
+    """The end of an HTTP message.
+
+    Fields:
+
+    .. attribute:: headers
+
+       Default value: ``[]``
+
+       Any trailing headers attached to this message, represented as a list of
+       (name, value) pairs. See :ref:`the header normalization rules
+       <headers-format>` for details.
+
+       Must be empty unless ``Transfer-Encoding: chunked`` is in use.
+
+    """
+
+    __slots__ = ("headers",)
+
+    headers: Headers
+
+    def __init__(
+        self,
+        *,
+        headers: Union[
+            Headers, List[Tuple[bytes, bytes]], List[Tuple[str, str]], None
+        ] = None,
+        _parsed: bool = False,
+    ) -> None:
+        super().__init__()
+        if headers is None:
+            headers = Headers([])
+        elif not isinstance(headers, Headers):
+            headers = normalize_and_validate(headers, _parsed=_parsed)
+
+        object.__setattr__(self, "headers", headers)
+
+    # This is an unhashable type.
+    __hash__ = None  # type: ignore
+
+
+@dataclass(frozen=True)
+class ConnectionClosed(Event):
+    """This event indicates that the sender has closed their outgoing
+    connection.
+
+    Note that this does not necessarily mean that they can't *receive* further
+    data, because TCP connections are composed to two one-way channels which
+    can be closed independently. See :ref:`closing` for details.
+
+    No fields.
+    """
+
+    pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_headers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_headers.py
new file mode 100644
index 0000000000000000000000000000000000000000..31da3e2b23b55a624b36f105e62a6902e63286aa
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_headers.py
@@ -0,0 +1,282 @@
+import re
+from typing import AnyStr, cast, List, overload, Sequence, Tuple, TYPE_CHECKING, Union
+
+from ._abnf import field_name, field_value
+from ._util import bytesify, LocalProtocolError, validate
+
+if TYPE_CHECKING:
+    from ._events import Request
+
+try:
+    from typing import Literal
+except ImportError:
+    from typing_extensions import Literal  # type: ignore
+
+CONTENT_LENGTH_MAX_DIGITS = 20  # allow up to 1 billion TB - 1
+
+
+# Facts
+# -----
+#
+# Headers are:
+#   keys: case-insensitive ascii
+#   values: mixture of ascii and raw bytes
+#
+# "Historically, HTTP has allowed field content with text in the ISO-8859-1
+# charset [ISO-8859-1], supporting other charsets only through use of
+# [RFC2047] encoding.  In practice, most HTTP header field values use only a
+# subset of the US-ASCII charset [USASCII]. Newly defined header fields SHOULD
+# limit their field values to US-ASCII octets.  A recipient SHOULD treat other
+# octets in field content (obs-text) as opaque data."
+# And it deprecates all non-ascii values
+#
+# Leading/trailing whitespace in header names is forbidden
+#
+# Values get leading/trailing whitespace stripped
+#
+# Content-Disposition actually needs to contain unicode semantically; to
+# accomplish this it has a terrifically weird way of encoding the filename
+# itself as ascii (and even this still has lots of cross-browser
+# incompatibilities)
+#
+# Order is important:
+# "a proxy MUST NOT change the order of these field values when forwarding a
+# message"
+# (and there are several headers where the order indicates a preference)
+#
+# Multiple occurences of the same header:
+# "A sender MUST NOT generate multiple header fields with the same field name
+# in a message unless either the entire field value for that header field is
+# defined as a comma-separated list [or the header is Set-Cookie which gets a
+# special exception]" - RFC 7230. (cookies are in RFC 6265)
+#
+# So every header aside from Set-Cookie can be merged by b", ".join if it
+# occurs repeatedly. But, of course, they can't necessarily be split by
+# .split(b","), because quoting.
+#
+# Given all this mess (case insensitive, duplicates allowed, order is
+# important, ...), there doesn't appear to be any standard way to handle
+# headers in Python -- they're almost like dicts, but... actually just
+# aren't. For now we punt and just use a super simple representation: headers
+# are a list of pairs
+#
+#   [(name1, value1), (name2, value2), ...]
+#
+# where all entries are bytestrings, names are lowercase and have no
+# leading/trailing whitespace, and values are bytestrings with no
+# leading/trailing whitespace. Searching and updating are done via naive O(n)
+# methods.
+#
+# Maybe a dict-of-lists would be better?
+
+_content_length_re = re.compile(rb"[0-9]+")
+_field_name_re = re.compile(field_name.encode("ascii"))
+_field_value_re = re.compile(field_value.encode("ascii"))
+
+
+class Headers(Sequence[Tuple[bytes, bytes]]):
+    """
+    A list-like interface that allows iterating over headers as byte-pairs
+    of (lowercased-name, value).
+
+    Internally we actually store the representation as three-tuples,
+    including both the raw original casing, in order to preserve casing
+    over-the-wire, and the lowercased name, for case-insensitive comparisions.
+
+    r = Request(
+        method="GET",
+        target="/",
+        headers=[("Host", "example.org"), ("Connection", "keep-alive")],
+        http_version="1.1",
+    )
+    assert r.headers == [
+        (b"host", b"example.org"),
+        (b"connection", b"keep-alive")
+    ]
+    assert r.headers.raw_items() == [
+        (b"Host", b"example.org"),
+        (b"Connection", b"keep-alive")
+    ]
+    """
+
+    __slots__ = "_full_items"
+
+    def __init__(self, full_items: List[Tuple[bytes, bytes, bytes]]) -> None:
+        self._full_items = full_items
+
+    def __bool__(self) -> bool:
+        return bool(self._full_items)
+
+    def __eq__(self, other: object) -> bool:
+        return list(self) == list(other)  # type: ignore
+
+    def __len__(self) -> int:
+        return len(self._full_items)
+
+    def __repr__(self) -> str:
+        return "<Headers(%s)>" % repr(list(self))
+
+    def __getitem__(self, idx: int) -> Tuple[bytes, bytes]:  # type: ignore[override]
+        _, name, value = self._full_items[idx]
+        return (name, value)
+
+    def raw_items(self) -> List[Tuple[bytes, bytes]]:
+        return [(raw_name, value) for raw_name, _, value in self._full_items]
+
+
+HeaderTypes = Union[
+    List[Tuple[bytes, bytes]],
+    List[Tuple[bytes, str]],
+    List[Tuple[str, bytes]],
+    List[Tuple[str, str]],
+]
+
+
+@overload
+def normalize_and_validate(headers: Headers, _parsed: Literal[True]) -> Headers:
+    ...
+
+
+@overload
+def normalize_and_validate(headers: HeaderTypes, _parsed: Literal[False]) -> Headers:
+    ...
+
+
+@overload
+def normalize_and_validate(
+    headers: Union[Headers, HeaderTypes], _parsed: bool = False
+) -> Headers:
+    ...
+
+
+def normalize_and_validate(
+    headers: Union[Headers, HeaderTypes], _parsed: bool = False
+) -> Headers:
+    new_headers = []
+    seen_content_length = None
+    saw_transfer_encoding = False
+    for name, value in headers:
+        # For headers coming out of the parser, we can safely skip some steps,
+        # because it always returns bytes and has already run these regexes
+        # over the data:
+        if not _parsed:
+            name = bytesify(name)
+            value = bytesify(value)
+            validate(_field_name_re, name, "Illegal header name {!r}", name)
+            validate(_field_value_re, value, "Illegal header value {!r}", value)
+        assert isinstance(name, bytes)
+        assert isinstance(value, bytes)
+
+        raw_name = name
+        name = name.lower()
+        if name == b"content-length":
+            lengths = {length.strip() for length in value.split(b",")}
+            if len(lengths) != 1:
+                raise LocalProtocolError("conflicting Content-Length headers")
+            value = lengths.pop()
+            validate(_content_length_re, value, "bad Content-Length")
+            if len(value) > CONTENT_LENGTH_MAX_DIGITS:
+                raise LocalProtocolError("bad Content-Length")
+            if seen_content_length is None:
+                seen_content_length = value
+                new_headers.append((raw_name, name, value))
+            elif seen_content_length != value:
+                raise LocalProtocolError("conflicting Content-Length headers")
+        elif name == b"transfer-encoding":
+            # "A server that receives a request message with a transfer coding
+            # it does not understand SHOULD respond with 501 (Not
+            # Implemented)."
+            # https://tools.ietf.org/html/rfc7230#section-3.3.1
+            if saw_transfer_encoding:
+                raise LocalProtocolError(
+                    "multiple Transfer-Encoding headers", error_status_hint=501
+                )
+            # "All transfer-coding names are case-insensitive"
+            # -- https://tools.ietf.org/html/rfc7230#section-4
+            value = value.lower()
+            if value != b"chunked":
+                raise LocalProtocolError(
+                    "Only Transfer-Encoding: chunked is supported",
+                    error_status_hint=501,
+                )
+            saw_transfer_encoding = True
+            new_headers.append((raw_name, name, value))
+        else:
+            new_headers.append((raw_name, name, value))
+    return Headers(new_headers)
+
+
+def get_comma_header(headers: Headers, name: bytes) -> List[bytes]:
+    # Should only be used for headers whose value is a list of
+    # comma-separated, case-insensitive values.
+    #
+    # The header name `name` is expected to be lower-case bytes.
+    #
+    # Connection: meets these criteria (including cast insensitivity).
+    #
+    # Content-Length: technically is just a single value (1*DIGIT), but the
+    # standard makes reference to implementations that do multiple values, and
+    # using this doesn't hurt. Ditto, case insensitivity doesn't things either
+    # way.
+    #
+    # Transfer-Encoding: is more complex (allows for quoted strings), so
+    # splitting on , is actually wrong. For example, this is legal:
+    #
+    #    Transfer-Encoding: foo; options="1,2", chunked
+    #
+    # and should be parsed as
+    #
+    #    foo; options="1,2"
+    #    chunked
+    #
+    # but this naive function will parse it as
+    #
+    #    foo; options="1
+    #    2"
+    #    chunked
+    #
+    # However, this is okay because the only thing we are going to do with
+    # any Transfer-Encoding is reject ones that aren't just "chunked", so
+    # both of these will be treated the same anyway.
+    #
+    # Expect: the only legal value is the literal string
+    # "100-continue". Splitting on commas is harmless. Case insensitive.
+    #
+    out: List[bytes] = []
+    for _, found_name, found_raw_value in headers._full_items:
+        if found_name == name:
+            found_raw_value = found_raw_value.lower()
+            for found_split_value in found_raw_value.split(b","):
+                found_split_value = found_split_value.strip()
+                if found_split_value:
+                    out.append(found_split_value)
+    return out
+
+
+def set_comma_header(headers: Headers, name: bytes, new_values: List[bytes]) -> Headers:
+    # The header name `name` is expected to be lower-case bytes.
+    #
+    # Note that when we store the header we use title casing for the header
+    # names, in order to match the conventional HTTP header style.
+    #
+    # Simply calling `.title()` is a blunt approach, but it's correct
+    # here given the cases where we're using `set_comma_header`...
+    #
+    # Connection, Content-Length, Transfer-Encoding.
+    new_headers: List[Tuple[bytes, bytes]] = []
+    for found_raw_name, found_name, found_raw_value in headers._full_items:
+        if found_name != name:
+            new_headers.append((found_raw_name, found_raw_value))
+    for new_value in new_values:
+        new_headers.append((name.title(), new_value))
+    return normalize_and_validate(new_headers)
+
+
+def has_expect_100_continue(request: "Request") -> bool:
+    # https://tools.ietf.org/html/rfc7231#section-5.1.1
+    # "A server that receives a 100-continue expectation in an HTTP/1.0 request
+    # MUST ignore that expectation."
+    if request.http_version < b"1.1":
+        return False
+    expect = get_comma_header(request.headers, b"expect")
+    return b"100-continue" in expect
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_readers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_readers.py
new file mode 100644
index 0000000000000000000000000000000000000000..576804cc282032526e0a932c9853d586a094bad0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_readers.py
@@ -0,0 +1,250 @@
+# Code to read HTTP data
+#
+# Strategy: each reader is a callable which takes a ReceiveBuffer object, and
+# either:
+# 1) consumes some of it and returns an Event
+# 2) raises a LocalProtocolError (for consistency -- e.g. we call validate()
+#    and it might raise a LocalProtocolError, so simpler just to always use
+#    this)
+# 3) returns None, meaning "I need more data"
+#
+# If they have a .read_eof attribute, then this will be called if an EOF is
+# received -- but this is optional. Either way, the actual ConnectionClosed
+# event will be generated afterwards.
+#
+# READERS is a dict describing how to pick a reader. It maps states to either:
+# - a reader
+# - or, for body readers, a dict of per-framing reader factories
+
+import re
+from typing import Any, Callable, Dict, Iterable, NoReturn, Optional, Tuple, Type, Union
+
+from ._abnf import chunk_header, header_field, request_line, status_line
+from ._events import Data, EndOfMessage, InformationalResponse, Request, Response
+from ._receivebuffer import ReceiveBuffer
+from ._state import (
+    CLIENT,
+    CLOSED,
+    DONE,
+    IDLE,
+    MUST_CLOSE,
+    SEND_BODY,
+    SEND_RESPONSE,
+    SERVER,
+)
+from ._util import LocalProtocolError, RemoteProtocolError, Sentinel, validate
+
+__all__ = ["READERS"]
+
+header_field_re = re.compile(header_field.encode("ascii"))
+obs_fold_re = re.compile(rb"[ \t]+")
+
+
+def _obsolete_line_fold(lines: Iterable[bytes]) -> Iterable[bytes]:
+    it = iter(lines)
+    last: Optional[bytes] = None
+    for line in it:
+        match = obs_fold_re.match(line)
+        if match:
+            if last is None:
+                raise LocalProtocolError("continuation line at start of headers")
+            if not isinstance(last, bytearray):
+                # Cast to a mutable type, avoiding copy on append to ensure O(n) time
+                last = bytearray(last)
+            last += b" "
+            last += line[match.end() :]
+        else:
+            if last is not None:
+                yield last
+            last = line
+    if last is not None:
+        yield last
+
+
+def _decode_header_lines(
+    lines: Iterable[bytes],
+) -> Iterable[Tuple[bytes, bytes]]:
+    for line in _obsolete_line_fold(lines):
+        matches = validate(header_field_re, line, "illegal header line: {!r}", line)
+        yield (matches["field_name"], matches["field_value"])
+
+
+request_line_re = re.compile(request_line.encode("ascii"))
+
+
+def maybe_read_from_IDLE_client(buf: ReceiveBuffer) -> Optional[Request]:
+    lines = buf.maybe_extract_lines()
+    if lines is None:
+        if buf.is_next_line_obviously_invalid_request_line():
+            raise LocalProtocolError("illegal request line")
+        return None
+    if not lines:
+        raise LocalProtocolError("no request line received")
+    matches = validate(
+        request_line_re, lines[0], "illegal request line: {!r}", lines[0]
+    )
+    return Request(
+        headers=list(_decode_header_lines(lines[1:])), _parsed=True, **matches
+    )
+
+
+status_line_re = re.compile(status_line.encode("ascii"))
+
+
+def maybe_read_from_SEND_RESPONSE_server(
+    buf: ReceiveBuffer,
+) -> Union[InformationalResponse, Response, None]:
+    lines = buf.maybe_extract_lines()
+    if lines is None:
+        if buf.is_next_line_obviously_invalid_request_line():
+            raise LocalProtocolError("illegal request line")
+        return None
+    if not lines:
+        raise LocalProtocolError("no response line received")
+    matches = validate(status_line_re, lines[0], "illegal status line: {!r}", lines[0])
+    http_version = (
+        b"1.1" if matches["http_version"] is None else matches["http_version"]
+    )
+    reason = b"" if matches["reason"] is None else matches["reason"]
+    status_code = int(matches["status_code"])
+    class_: Union[Type[InformationalResponse], Type[Response]] = (
+        InformationalResponse if status_code < 200 else Response
+    )
+    return class_(
+        headers=list(_decode_header_lines(lines[1:])),
+        _parsed=True,
+        status_code=status_code,
+        reason=reason,
+        http_version=http_version,
+    )
+
+
+class ContentLengthReader:
+    def __init__(self, length: int) -> None:
+        self._length = length
+        self._remaining = length
+
+    def __call__(self, buf: ReceiveBuffer) -> Union[Data, EndOfMessage, None]:
+        if self._remaining == 0:
+            return EndOfMessage()
+        data = buf.maybe_extract_at_most(self._remaining)
+        if data is None:
+            return None
+        self._remaining -= len(data)
+        return Data(data=data)
+
+    def read_eof(self) -> NoReturn:
+        raise RemoteProtocolError(
+            "peer closed connection without sending complete message body "
+            "(received {} bytes, expected {})".format(
+                self._length - self._remaining, self._length
+            )
+        )
+
+
+chunk_header_re = re.compile(chunk_header.encode("ascii"))
+
+
+class ChunkedReader:
+    def __init__(self) -> None:
+        self._bytes_in_chunk = 0
+        # After reading a chunk, we have to throw away the trailing \r\n.
+        # This tracks the bytes that we need to match and throw away.
+        self._bytes_to_discard = b""
+        self._reading_trailer = False
+
+    def __call__(self, buf: ReceiveBuffer) -> Union[Data, EndOfMessage, None]:
+        if self._reading_trailer:
+            lines = buf.maybe_extract_lines()
+            if lines is None:
+                return None
+            return EndOfMessage(headers=list(_decode_header_lines(lines)))
+        if self._bytes_to_discard:
+            data = buf.maybe_extract_at_most(len(self._bytes_to_discard))
+            if data is None:
+                return None
+            if data != self._bytes_to_discard[: len(data)]:
+                raise LocalProtocolError(
+                    f"malformed chunk footer: {data!r} (expected {self._bytes_to_discard!r})"
+                )
+            self._bytes_to_discard = self._bytes_to_discard[len(data) :]
+            if self._bytes_to_discard:
+                return None
+            # else, fall through and read some more
+        assert self._bytes_to_discard == b""
+        if self._bytes_in_chunk == 0:
+            # We need to refill our chunk count
+            chunk_header = buf.maybe_extract_next_line()
+            if chunk_header is None:
+                return None
+            matches = validate(
+                chunk_header_re,
+                chunk_header,
+                "illegal chunk header: {!r}",
+                chunk_header,
+            )
+            # XX FIXME: we discard chunk extensions. Does anyone care?
+            self._bytes_in_chunk = int(matches["chunk_size"], base=16)
+            if self._bytes_in_chunk == 0:
+                self._reading_trailer = True
+                return self(buf)
+            chunk_start = True
+        else:
+            chunk_start = False
+        assert self._bytes_in_chunk > 0
+        data = buf.maybe_extract_at_most(self._bytes_in_chunk)
+        if data is None:
+            return None
+        self._bytes_in_chunk -= len(data)
+        if self._bytes_in_chunk == 0:
+            self._bytes_to_discard = b"\r\n"
+            chunk_end = True
+        else:
+            chunk_end = False
+        return Data(data=data, chunk_start=chunk_start, chunk_end=chunk_end)
+
+    def read_eof(self) -> NoReturn:
+        raise RemoteProtocolError(
+            "peer closed connection without sending complete message body "
+            "(incomplete chunked read)"
+        )
+
+
+class Http10Reader:
+    def __call__(self, buf: ReceiveBuffer) -> Optional[Data]:
+        data = buf.maybe_extract_at_most(999999999)
+        if data is None:
+            return None
+        return Data(data=data)
+
+    def read_eof(self) -> EndOfMessage:
+        return EndOfMessage()
+
+
+def expect_nothing(buf: ReceiveBuffer) -> None:
+    if buf:
+        raise LocalProtocolError("Got data when expecting EOF")
+    return None
+
+
+ReadersType = Dict[
+    Union[Type[Sentinel], Tuple[Type[Sentinel], Type[Sentinel]]],
+    Union[Callable[..., Any], Dict[str, Callable[..., Any]]],
+]
+
+READERS: ReadersType = {
+    (CLIENT, IDLE): maybe_read_from_IDLE_client,
+    (SERVER, IDLE): maybe_read_from_SEND_RESPONSE_server,
+    (SERVER, SEND_RESPONSE): maybe_read_from_SEND_RESPONSE_server,
+    (CLIENT, DONE): expect_nothing,
+    (CLIENT, MUST_CLOSE): expect_nothing,
+    (CLIENT, CLOSED): expect_nothing,
+    (SERVER, DONE): expect_nothing,
+    (SERVER, MUST_CLOSE): expect_nothing,
+    (SERVER, CLOSED): expect_nothing,
+    SEND_BODY: {
+        "chunked": ChunkedReader,
+        "content-length": ContentLengthReader,
+        "http/1.0": Http10Reader,
+    },
+}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_receivebuffer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_receivebuffer.py
new file mode 100644
index 0000000000000000000000000000000000000000..e5c4e08a56f5081e87103f38b4add6ce1b730204
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_receivebuffer.py
@@ -0,0 +1,153 @@
+import re
+import sys
+from typing import List, Optional, Union
+
+__all__ = ["ReceiveBuffer"]
+
+
+# Operations we want to support:
+# - find next \r\n or \r\n\r\n (\n or \n\n are also acceptable),
+#   or wait until there is one
+# - read at-most-N bytes
+# Goals:
+# - on average, do this fast
+# - worst case, do this in O(n) where n is the number of bytes processed
+# Plan:
+# - store bytearray, offset, how far we've searched for a separator token
+# - use the how-far-we've-searched data to avoid rescanning
+# - while doing a stream of uninterrupted processing, advance offset instead
+#   of constantly copying
+# WARNING:
+# - I haven't benchmarked or profiled any of this yet.
+#
+# Note that starting in Python 3.4, deleting the initial n bytes from a
+# bytearray is amortized O(n), thanks to some excellent work by Antoine
+# Martin:
+#
+#     https://bugs.python.org/issue19087
+#
+# This means that if we only supported 3.4+, we could get rid of the code here
+# involving self._start and self.compress, because it's doing exactly the same
+# thing that bytearray now does internally.
+#
+# BUT unfortunately, we still support 2.7, and reading short segments out of a
+# long buffer MUST be O(bytes read) to avoid DoS issues, so we can't actually
+# delete this code. Yet:
+#
+#     https://pythonclock.org/
+#
+# (Two things to double-check first though: make sure PyPy also has the
+# optimization, and benchmark to make sure it's a win, since we do have a
+# slightly clever thing where we delay calling compress() until we've
+# processed a whole event, which could in theory be slightly more efficient
+# than the internal bytearray support.)
+blank_line_regex = re.compile(b"\n\r?\n", re.MULTILINE)
+
+
+class ReceiveBuffer:
+    def __init__(self) -> None:
+        self._data = bytearray()
+        self._next_line_search = 0
+        self._multiple_lines_search = 0
+
+    def __iadd__(self, byteslike: Union[bytes, bytearray]) -> "ReceiveBuffer":
+        self._data += byteslike
+        return self
+
+    def __bool__(self) -> bool:
+        return bool(len(self))
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    # for @property unprocessed_data
+    def __bytes__(self) -> bytes:
+        return bytes(self._data)
+
+    def _extract(self, count: int) -> bytearray:
+        # extracting an initial slice of the data buffer and return it
+        out = self._data[:count]
+        del self._data[:count]
+
+        self._next_line_search = 0
+        self._multiple_lines_search = 0
+
+        return out
+
+    def maybe_extract_at_most(self, count: int) -> Optional[bytearray]:
+        """
+        Extract a fixed number of bytes from the buffer.
+        """
+        out = self._data[:count]
+        if not out:
+            return None
+
+        return self._extract(count)
+
+    def maybe_extract_next_line(self) -> Optional[bytearray]:
+        """
+        Extract the first line, if it is completed in the buffer.
+        """
+        # Only search in buffer space that we've not already looked at.
+        search_start_index = max(0, self._next_line_search - 1)
+        partial_idx = self._data.find(b"\r\n", search_start_index)
+
+        if partial_idx == -1:
+            self._next_line_search = len(self._data)
+            return None
+
+        # + 2 is to compensate len(b"\r\n")
+        idx = partial_idx + 2
+
+        return self._extract(idx)
+
+    def maybe_extract_lines(self) -> Optional[List[bytearray]]:
+        """
+        Extract everything up to the first blank line, and return a list of lines.
+        """
+        # Handle the case where we have an immediate empty line.
+        if self._data[:1] == b"\n":
+            self._extract(1)
+            return []
+
+        if self._data[:2] == b"\r\n":
+            self._extract(2)
+            return []
+
+        # Only search in buffer space that we've not already looked at.
+        match = blank_line_regex.search(self._data, self._multiple_lines_search)
+        if match is None:
+            self._multiple_lines_search = max(0, len(self._data) - 2)
+            return None
+
+        # Truncate the buffer and return it.
+        idx = match.span(0)[-1]
+        out = self._extract(idx)
+        lines = out.split(b"\n")
+
+        for line in lines:
+            if line.endswith(b"\r"):
+                del line[-1]
+
+        assert lines[-2] == lines[-1] == b""
+
+        del lines[-2:]
+
+        return lines
+
+    # In theory we should wait until `\r\n` before starting to validate
+    # incoming data. However it's interesting to detect (very) invalid data
+    # early given they might not even contain `\r\n` at all (hence only
+    # timeout will get rid of them).
+    # This is not a 100% effective detection but more of a cheap sanity check
+    # allowing for early abort in some useful cases.
+    # This is especially interesting when peer is messing up with HTTPS and
+    # sent us a TLS stream where we were expecting plain HTTP given all
+    # versions of TLS so far start handshake with a 0x16 message type code.
+    def is_next_line_obviously_invalid_request_line(self) -> bool:
+        try:
+            # HTTP header line must not contain non-printable characters
+            # and should not start with a space
+            return self._data[0] < 0x21
+        except IndexError:
+            return False
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_state.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_state.py
new file mode 100644
index 0000000000000000000000000000000000000000..3ad444b043e3f3d6c05c2d9d84d5119312bfaa34
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_state.py
@@ -0,0 +1,365 @@
+################################################################
+# The core state machine
+################################################################
+#
+# Rule 1: everything that affects the state machine and state transitions must
+# live here in this file. As much as possible goes into the table-based
+# representation, but for the bits that don't quite fit, the actual code and
+# state must nonetheless live here.
+#
+# Rule 2: this file does not know about what role we're playing; it only knows
+# about HTTP request/response cycles in the abstract. This ensures that we
+# don't cheat and apply different rules to local and remote parties.
+#
+#
+# Theory of operation
+# ===================
+#
+# Possibly the simplest way to think about this is that we actually have 5
+# different state machines here. Yes, 5. These are:
+#
+# 1) The client state, with its complicated automaton (see the docs)
+# 2) The server state, with its complicated automaton (see the docs)
+# 3) The keep-alive state, with possible states {True, False}
+# 4) The SWITCH_CONNECT state, with possible states {False, True}
+# 5) The SWITCH_UPGRADE state, with possible states {False, True}
+#
+# For (3)-(5), the first state listed is the initial state.
+#
+# (1)-(3) are stored explicitly in member variables. The last
+# two are stored implicitly in the pending_switch_proposals set as:
+#   (state of 4) == (_SWITCH_CONNECT in pending_switch_proposals)
+#   (state of 5) == (_SWITCH_UPGRADE in pending_switch_proposals)
+#
+# And each of these machines has two different kinds of transitions:
+#
+# a) Event-triggered
+# b) State-triggered
+#
+# Event triggered is the obvious thing that you'd think it is: some event
+# happens, and if it's the right event at the right time then a transition
+# happens. But there are somewhat complicated rules for which machines can
+# "see" which events. (As a rule of thumb, if a machine "sees" an event, this
+# means two things: the event can affect the machine, and if the machine is
+# not in a state where it expects that event then it's an error.) These rules
+# are:
+#
+# 1) The client machine sees all h11.events objects emitted by the client.
+#
+# 2) The server machine sees all h11.events objects emitted by the server.
+#
+#    It also sees the client's Request event.
+#
+#    And sometimes, server events are annotated with a _SWITCH_* event. For
+#    example, we can have a (Response, _SWITCH_CONNECT) event, which is
+#    different from a regular Response event.
+#
+# 3) The keep-alive machine sees the process_keep_alive_disabled() event
+#    (which is derived from Request/Response events), and this event
+#    transitions it from True -> False, or from False -> False. There's no way
+#    to transition back.
+#
+# 4&5) The _SWITCH_* machines transition from False->True when we get a
+#    Request that proposes the relevant type of switch (via
+#    process_client_switch_proposals), and they go from True->False when we
+#    get a Response that has no _SWITCH_* annotation.
+#
+# So that's event-triggered transitions.
+#
+# State-triggered transitions are less standard. What they do here is couple
+# the machines together. The way this works is, when certain *joint*
+# configurations of states are achieved, then we automatically transition to a
+# new *joint* state. So, for example, if we're ever in a joint state with
+#
+#   client: DONE
+#   keep-alive: False
+#
+# then the client state immediately transitions to:
+#
+#   client: MUST_CLOSE
+#
+# This is fundamentally different from an event-based transition, because it
+# doesn't matter how we arrived at the {client: DONE, keep-alive: False} state
+# -- maybe the client transitioned SEND_BODY -> DONE, or keep-alive
+# transitioned True -> False. Either way, once this precondition is satisfied,
+# this transition is immediately triggered.
+#
+# What if two conflicting state-based transitions get enabled at the same
+# time?  In practice there's only one case where this arises (client DONE ->
+# MIGHT_SWITCH_PROTOCOL versus DONE -> MUST_CLOSE), and we resolve it by
+# explicitly prioritizing the DONE -> MIGHT_SWITCH_PROTOCOL transition.
+#
+# Implementation
+# --------------
+#
+# The event-triggered transitions for the server and client machines are all
+# stored explicitly in a table. Ditto for the state-triggered transitions that
+# involve just the server and client state.
+#
+# The transitions for the other machines, and the state-triggered transitions
+# that involve the other machines, are written out as explicit Python code.
+#
+# It'd be nice if there were some cleaner way to do all this. This isn't
+# *too* terrible, but I feel like it could probably be better.
+#
+# WARNING
+# -------
+#
+# The script that generates the state machine diagrams for the docs knows how
+# to read out the EVENT_TRIGGERED_TRANSITIONS and STATE_TRIGGERED_TRANSITIONS
+# tables. But it can't automatically read the transitions that are written
+# directly in Python code. So if you touch those, you need to also update the
+# script to keep it in sync!
+from typing import cast, Dict, Optional, Set, Tuple, Type, Union
+
+from ._events import *
+from ._util import LocalProtocolError, Sentinel
+
+# Everything in __all__ gets re-exported as part of the h11 public API.
+__all__ = [
+    "CLIENT",
+    "SERVER",
+    "IDLE",
+    "SEND_RESPONSE",
+    "SEND_BODY",
+    "DONE",
+    "MUST_CLOSE",
+    "CLOSED",
+    "MIGHT_SWITCH_PROTOCOL",
+    "SWITCHED_PROTOCOL",
+    "ERROR",
+]
+
+
+class CLIENT(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SERVER(Sentinel, metaclass=Sentinel):
+    pass
+
+
+# States
+class IDLE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SEND_RESPONSE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SEND_BODY(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class DONE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class MUST_CLOSE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class CLOSED(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class ERROR(Sentinel, metaclass=Sentinel):
+    pass
+
+
+# Switch types
+class MIGHT_SWITCH_PROTOCOL(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class SWITCHED_PROTOCOL(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class _SWITCH_UPGRADE(Sentinel, metaclass=Sentinel):
+    pass
+
+
+class _SWITCH_CONNECT(Sentinel, metaclass=Sentinel):
+    pass
+
+
+EventTransitionType = Dict[
+    Type[Sentinel],
+    Dict[
+        Type[Sentinel],
+        Dict[Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]], Type[Sentinel]],
+    ],
+]
+
+EVENT_TRIGGERED_TRANSITIONS: EventTransitionType = {
+    CLIENT: {
+        IDLE: {Request: SEND_BODY, ConnectionClosed: CLOSED},
+        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
+        DONE: {ConnectionClosed: CLOSED},
+        MUST_CLOSE: {ConnectionClosed: CLOSED},
+        CLOSED: {ConnectionClosed: CLOSED},
+        MIGHT_SWITCH_PROTOCOL: {},
+        SWITCHED_PROTOCOL: {},
+        ERROR: {},
+    },
+    SERVER: {
+        IDLE: {
+            ConnectionClosed: CLOSED,
+            Response: SEND_BODY,
+            # Special case: server sees client Request events, in this form
+            (Request, CLIENT): SEND_RESPONSE,
+        },
+        SEND_RESPONSE: {
+            InformationalResponse: SEND_RESPONSE,
+            Response: SEND_BODY,
+            (InformationalResponse, _SWITCH_UPGRADE): SWITCHED_PROTOCOL,
+            (Response, _SWITCH_CONNECT): SWITCHED_PROTOCOL,
+        },
+        SEND_BODY: {Data: SEND_BODY, EndOfMessage: DONE},
+        DONE: {ConnectionClosed: CLOSED},
+        MUST_CLOSE: {ConnectionClosed: CLOSED},
+        CLOSED: {ConnectionClosed: CLOSED},
+        SWITCHED_PROTOCOL: {},
+        ERROR: {},
+    },
+}
+
+StateTransitionType = Dict[
+    Tuple[Type[Sentinel], Type[Sentinel]], Dict[Type[Sentinel], Type[Sentinel]]
+]
+
+# NB: there are also some special-case state-triggered transitions hard-coded
+# into _fire_state_triggered_transitions below.
+STATE_TRIGGERED_TRANSITIONS: StateTransitionType = {
+    # (Client state, Server state) -> new states
+    # Protocol negotiation
+    (MIGHT_SWITCH_PROTOCOL, SWITCHED_PROTOCOL): {CLIENT: SWITCHED_PROTOCOL},
+    # Socket shutdown
+    (CLOSED, DONE): {SERVER: MUST_CLOSE},
+    (CLOSED, IDLE): {SERVER: MUST_CLOSE},
+    (ERROR, DONE): {SERVER: MUST_CLOSE},
+    (DONE, CLOSED): {CLIENT: MUST_CLOSE},
+    (IDLE, CLOSED): {CLIENT: MUST_CLOSE},
+    (DONE, ERROR): {CLIENT: MUST_CLOSE},
+}
+
+
+class ConnectionState:
+    def __init__(self) -> None:
+        # Extra bits of state that don't quite fit into the state model.
+
+        # If this is False then it enables the automatic DONE -> MUST_CLOSE
+        # transition. Don't set this directly; call .keep_alive_disabled()
+        self.keep_alive = True
+
+        # This is a subset of {UPGRADE, CONNECT}, containing the proposals
+        # made by the client for switching protocols.
+        self.pending_switch_proposals: Set[Type[Sentinel]] = set()
+
+        self.states: Dict[Type[Sentinel], Type[Sentinel]] = {CLIENT: IDLE, SERVER: IDLE}
+
+    def process_error(self, role: Type[Sentinel]) -> None:
+        self.states[role] = ERROR
+        self._fire_state_triggered_transitions()
+
+    def process_keep_alive_disabled(self) -> None:
+        self.keep_alive = False
+        self._fire_state_triggered_transitions()
+
+    def process_client_switch_proposal(self, switch_event: Type[Sentinel]) -> None:
+        self.pending_switch_proposals.add(switch_event)
+        self._fire_state_triggered_transitions()
+
+    def process_event(
+        self,
+        role: Type[Sentinel],
+        event_type: Type[Event],
+        server_switch_event: Optional[Type[Sentinel]] = None,
+    ) -> None:
+        _event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]] = event_type
+        if server_switch_event is not None:
+            assert role is SERVER
+            if server_switch_event not in self.pending_switch_proposals:
+                raise LocalProtocolError(
+                    "Received server _SWITCH_UPGRADE event without a pending proposal"
+                )
+            _event_type = (event_type, server_switch_event)
+        if server_switch_event is None and _event_type is Response:
+            self.pending_switch_proposals = set()
+        self._fire_event_triggered_transitions(role, _event_type)
+        # Special case: the server state does get to see Request
+        # events.
+        if _event_type is Request:
+            assert role is CLIENT
+            self._fire_event_triggered_transitions(SERVER, (Request, CLIENT))
+        self._fire_state_triggered_transitions()
+
+    def _fire_event_triggered_transitions(
+        self,
+        role: Type[Sentinel],
+        event_type: Union[Type[Event], Tuple[Type[Event], Type[Sentinel]]],
+    ) -> None:
+        state = self.states[role]
+        try:
+            new_state = EVENT_TRIGGERED_TRANSITIONS[role][state][event_type]
+        except KeyError:
+            event_type = cast(Type[Event], event_type)
+            raise LocalProtocolError(
+                "can't handle event type {} when role={} and state={}".format(
+                    event_type.__name__, role, self.states[role]
+                )
+            ) from None
+        self.states[role] = new_state
+
+    def _fire_state_triggered_transitions(self) -> None:
+        # We apply these rules repeatedly until converging on a fixed point
+        while True:
+            start_states = dict(self.states)
+
+            # It could happen that both these special-case transitions are
+            # enabled at the same time:
+            #
+            #    DONE -> MIGHT_SWITCH_PROTOCOL
+            #    DONE -> MUST_CLOSE
+            #
+            # For example, this will always be true of a HTTP/1.0 client
+            # requesting CONNECT.  If this happens, the protocol switch takes
+            # priority. From there the client will either go to
+            # SWITCHED_PROTOCOL, in which case it's none of our business when
+            # they close the connection, or else the server will deny the
+            # request, in which case the client will go back to DONE and then
+            # from there to MUST_CLOSE.
+            if self.pending_switch_proposals:
+                if self.states[CLIENT] is DONE:
+                    self.states[CLIENT] = MIGHT_SWITCH_PROTOCOL
+
+            if not self.pending_switch_proposals:
+                if self.states[CLIENT] is MIGHT_SWITCH_PROTOCOL:
+                    self.states[CLIENT] = DONE
+
+            if not self.keep_alive:
+                for role in (CLIENT, SERVER):
+                    if self.states[role] is DONE:
+                        self.states[role] = MUST_CLOSE
+
+            # Tabular state-triggered transitions
+            joint_state = (self.states[CLIENT], self.states[SERVER])
+            changes = STATE_TRIGGERED_TRANSITIONS.get(joint_state, {})
+            self.states.update(changes)
+
+            if self.states == start_states:
+                # Fixed point reached
+                return
+
+    def start_next_cycle(self) -> None:
+        if self.states != {CLIENT: DONE, SERVER: DONE}:
+            raise LocalProtocolError(
+                f"not in a reusable state. self.states={self.states}"
+            )
+        # Can't reach DONE/DONE with any of these active, but still, let's be
+        # sure.
+        assert self.keep_alive
+        assert not self.pending_switch_proposals
+        self.states = {CLIENT: IDLE, SERVER: IDLE}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_util.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_util.py
new file mode 100644
index 0000000000000000000000000000000000000000..6718445290770e028ea2f1f662026c9a0b0991db
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_util.py
@@ -0,0 +1,135 @@
+from typing import Any, Dict, NoReturn, Pattern, Tuple, Type, TypeVar, Union
+
+__all__ = [
+    "ProtocolError",
+    "LocalProtocolError",
+    "RemoteProtocolError",
+    "validate",
+    "bytesify",
+]
+
+
+class ProtocolError(Exception):
+    """Exception indicating a violation of the HTTP/1.1 protocol.
+
+    This as an abstract base class, with two concrete base classes:
+    :exc:`LocalProtocolError`, which indicates that you tried to do something
+    that HTTP/1.1 says is illegal, and :exc:`RemoteProtocolError`, which
+    indicates that the remote peer tried to do something that HTTP/1.1 says is
+    illegal. See :ref:`error-handling` for details.
+
+    In addition to the normal :exc:`Exception` features, it has one attribute:
+
+    .. attribute:: error_status_hint
+
+       This gives a suggestion as to what status code a server might use if
+       this error occurred as part of a request.
+
+       For a :exc:`RemoteProtocolError`, this is useful as a suggestion for
+       how you might want to respond to a misbehaving peer, if you're
+       implementing a server.
+
+       For a :exc:`LocalProtocolError`, this can be taken as a suggestion for
+       how your peer might have responded to *you* if h11 had allowed you to
+       continue.
+
+       The default is 400 Bad Request, a generic catch-all for protocol
+       violations.
+
+    """
+
+    def __init__(self, msg: str, error_status_hint: int = 400) -> None:
+        if type(self) is ProtocolError:
+            raise TypeError("tried to directly instantiate ProtocolError")
+        Exception.__init__(self, msg)
+        self.error_status_hint = error_status_hint
+
+
+# Strategy: there are a number of public APIs where a LocalProtocolError can
+# be raised (send(), all the different event constructors, ...), and only one
+# public API where RemoteProtocolError can be raised
+# (receive_data()). Therefore we always raise LocalProtocolError internally,
+# and then receive_data will translate this into a RemoteProtocolError.
+#
+# Internally:
+#   LocalProtocolError is the generic "ProtocolError".
+# Externally:
+#   LocalProtocolError is for local errors and RemoteProtocolError is for
+#   remote errors.
+class LocalProtocolError(ProtocolError):
+    def _reraise_as_remote_protocol_error(self) -> NoReturn:
+        # After catching a LocalProtocolError, use this method to re-raise it
+        # as a RemoteProtocolError. This method must be called from inside an
+        # except: block.
+        #
+        # An easy way to get an equivalent RemoteProtocolError is just to
+        # modify 'self' in place.
+        self.__class__ = RemoteProtocolError  # type: ignore
+        # But the re-raising is somewhat non-trivial -- you might think that
+        # now that we've modified the in-flight exception object, that just
+        # doing 'raise' to re-raise it would be enough. But it turns out that
+        # this doesn't work, because Python tracks the exception type
+        # (exc_info[0]) separately from the exception object (exc_info[1]),
+        # and we only modified the latter. So we really do need to re-raise
+        # the new type explicitly.
+        # On py3, the traceback is part of the exception object, so our
+        # in-place modification preserved it and we can just re-raise:
+        raise self
+
+
+class RemoteProtocolError(ProtocolError):
+    pass
+
+
+def validate(
+    regex: Pattern[bytes], data: bytes, msg: str = "malformed data", *format_args: Any
+) -> Dict[str, bytes]:
+    match = regex.fullmatch(data)
+    if not match:
+        if format_args:
+            msg = msg.format(*format_args)
+        raise LocalProtocolError(msg)
+    return match.groupdict()
+
+
+# Sentinel values
+#
+# - Inherit identity-based comparison and hashing from object
+# - Have a nice repr
+# - Have a *bonus property*: type(sentinel) is sentinel
+#
+# The bonus property is useful if you want to take the return value from
+# next_event() and do some sort of dispatch based on type(event).
+
+_T_Sentinel = TypeVar("_T_Sentinel", bound="Sentinel")
+
+
+class Sentinel(type):
+    def __new__(
+        cls: Type[_T_Sentinel],
+        name: str,
+        bases: Tuple[type, ...],
+        namespace: Dict[str, Any],
+        **kwds: Any
+    ) -> _T_Sentinel:
+        assert bases == (Sentinel,)
+        v = super().__new__(cls, name, bases, namespace, **kwds)
+        v.__class__ = v  # type: ignore
+        return v
+
+    def __repr__(self) -> str:
+        return self.__name__
+
+
+# Used for methods, request targets, HTTP versions, header names, and header
+# values. Accepts ascii-strings, or bytes/bytearray/memoryview/..., and always
+# returns bytes.
+def bytesify(s: Union[bytes, bytearray, memoryview, int, str]) -> bytes:
+    # Fast-path:
+    if type(s) is bytes:
+        return s
+    if isinstance(s, str):
+        s = s.encode("ascii")
+    if isinstance(s, int):
+        raise TypeError("expected bytes-like object, not int")
+    return bytes(s)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_version.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_version.py
new file mode 100644
index 0000000000000000000000000000000000000000..76e7327b8617c9d12236f511414d5eb58e98a44b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_version.py
@@ -0,0 +1,16 @@
+# This file must be kept very simple, because it is consumed from several
+# places -- it is imported by h11/__init__.py, execfile'd by setup.py, etc.
+
+# We use a simple scheme:
+#   1.0.0 -> 1.0.0+dev -> 1.1.0 -> 1.1.0+dev
+# where the +dev versions are never released into the wild, they're just what
+# we stick into the VCS in between releases.
+#
+# This is compatible with PEP 440:
+#   http://legacy.python.org/dev/peps/pep-0440/
+# via the use of the "local suffix" "+dev", which is disallowed on index
+# servers and causes 1.0.0+dev to sort after plain 1.0.0, which is what we
+# want. (Contrast with the special suffix 1.0.0.dev, which sorts *before*
+# 1.0.0.)
+
+__version__ = "0.16.0"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_writers.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_writers.py
new file mode 100644
index 0000000000000000000000000000000000000000..939cdb912a9debaea07fbf3a9ac04549c44d077c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/_writers.py
@@ -0,0 +1,145 @@
+# Code to read HTTP data
+#
+# Strategy: each writer takes an event + a write-some-bytes function, which is
+# calls.
+#
+# WRITERS is a dict describing how to pick a reader. It maps states to either:
+# - a writer
+# - or, for body writers, a dict of framin-dependent writer factories
+
+from typing import Any, Callable, Dict, List, Tuple, Type, Union
+
+from ._events import Data, EndOfMessage, Event, InformationalResponse, Request, Response
+from ._headers import Headers
+from ._state import CLIENT, IDLE, SEND_BODY, SEND_RESPONSE, SERVER
+from ._util import LocalProtocolError, Sentinel
+
+__all__ = ["WRITERS"]
+
+Writer = Callable[[bytes], Any]
+
+
+def write_headers(headers: Headers, write: Writer) -> None:
+    # "Since the Host field-value is critical information for handling a
+    # request, a user agent SHOULD generate Host as the first header field
+    # following the request-line." - RFC 7230
+    raw_items = headers._full_items
+    for raw_name, name, value in raw_items:
+        if name == b"host":
+            write(b"%s: %s\r\n" % (raw_name, value))
+    for raw_name, name, value in raw_items:
+        if name != b"host":
+            write(b"%s: %s\r\n" % (raw_name, value))
+    write(b"\r\n")
+
+
+def write_request(request: Request, write: Writer) -> None:
+    if request.http_version != b"1.1":
+        raise LocalProtocolError("I only send HTTP/1.1")
+    write(b"%s %s HTTP/1.1\r\n" % (request.method, request.target))
+    write_headers(request.headers, write)
+
+
+# Shared between InformationalResponse and Response
+def write_any_response(
+    response: Union[InformationalResponse, Response], write: Writer
+) -> None:
+    if response.http_version != b"1.1":
+        raise LocalProtocolError("I only send HTTP/1.1")
+    status_bytes = str(response.status_code).encode("ascii")
+    # We don't bother sending ascii status messages like "OK"; they're
+    # optional and ignored by the protocol. (But the space after the numeric
+    # status code is mandatory.)
+    #
+    # XX FIXME: could at least make an effort to pull out the status message
+    # from stdlib's http.HTTPStatus table. Or maybe just steal their enums
+    # (either by import or copy/paste). We already accept them as status codes
+    # since they're of type IntEnum < int.
+    write(b"HTTP/1.1 %s %s\r\n" % (status_bytes, response.reason))
+    write_headers(response.headers, write)
+
+
+class BodyWriter:
+    def __call__(self, event: Event, write: Writer) -> None:
+        if type(event) is Data:
+            self.send_data(event.data, write)
+        elif type(event) is EndOfMessage:
+            self.send_eom(event.headers, write)
+        else:  # pragma: no cover
+            assert False
+
+    def send_data(self, data: bytes, write: Writer) -> None:
+        pass
+
+    def send_eom(self, headers: Headers, write: Writer) -> None:
+        pass
+
+
+#
+# These are all careful not to do anything to 'data' except call len(data) and
+# write(data). This allows us to transparently pass-through funny objects,
+# like placeholder objects referring to files on disk that will be sent via
+# sendfile(2).
+#
+class ContentLengthWriter(BodyWriter):
+    def __init__(self, length: int) -> None:
+        self._length = length
+
+    def send_data(self, data: bytes, write: Writer) -> None:
+        self._length -= len(data)
+        if self._length < 0:
+            raise LocalProtocolError("Too much data for declared Content-Length")
+        write(data)
+
+    def send_eom(self, headers: Headers, write: Writer) -> None:
+        if self._length != 0:
+            raise LocalProtocolError("Too little data for declared Content-Length")
+        if headers:
+            raise LocalProtocolError("Content-Length and trailers don't mix")
+
+
+class ChunkedWriter(BodyWriter):
+    def send_data(self, data: bytes, write: Writer) -> None:
+        # if we encoded 0-length data in the naive way, it would look like an
+        # end-of-message.
+        if not data:
+            return
+        write(b"%x\r\n" % len(data))
+        write(data)
+        write(b"\r\n")
+
+    def send_eom(self, headers: Headers, write: Writer) -> None:
+        write(b"0\r\n")
+        write_headers(headers, write)
+
+
+class Http10Writer(BodyWriter):
+    def send_data(self, data: bytes, write: Writer) -> None:
+        write(data)
+
+    def send_eom(self, headers: Headers, write: Writer) -> None:
+        if headers:
+            raise LocalProtocolError("can't send trailers to HTTP/1.0 client")
+        # no need to close the socket ourselves, that will be taken care of by
+        # Connection: close machinery
+
+
+WritersType = Dict[
+    Union[Tuple[Type[Sentinel], Type[Sentinel]], Type[Sentinel]],
+    Union[
+        Dict[str, Type[BodyWriter]],
+        Callable[[Union[InformationalResponse, Response], Writer], None],
+        Callable[[Request, Writer], None],
+    ],
+]
+
+WRITERS: WritersType = {
+    (CLIENT, IDLE): write_request,
+    (SERVER, IDLE): write_any_response,
+    (SERVER, SEND_RESPONSE): write_any_response,
+    SEND_BODY: {
+        "chunked": ChunkedWriter,
+        "content-length": ContentLengthWriter,
+        "http/1.0": Http10Writer,
+    },
+}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..f5642f79f21d872f010979dcf6f0c4a415acc19d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/h11/py.typed
@@ -0,0 +1 @@
+Marker
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..58c07798f2c711fbf078a1055366898dc8bc0dc3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/METADATA
@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: hf-xet
+Version: 1.7.0
+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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..a919a86be78272a1ae0bc9c5a09f0969d8ccd19e
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/RECORD
@@ -0,0 +1,9 @@
+hf_xet-1.7.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+hf_xet-1.7.0.dist-info/METADATA,sha256=BZdbEjnxiLtBhTnxeO9oppPqaCTyDDBYOgLuqU-vZQo,4882
+hf_xet-1.7.0.dist-info/RECORD,,
+hf_xet-1.7.0.dist-info/WHEEL,sha256=O5HlGvsA5bcQCScIeZNjeZZZunIWDWPVtNWojda8dSQ,143
+hf_xet-1.7.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+hf_xet-1.7.0.dist-info/sboms/hf_xet.cyclonedx.json,sha256=y2D8YJOXRzQZZT-1brjD__DXIqN3XzrCB55A7FUKsuQ,282478
+hf_xet/__init__.py,sha256=E8UDdyQ8glZ_nve9hHEf22bPang8-RKx4VuApXYeQUo,107
+hf_xet/__pycache__/__init__.cpython-311.pyc,,
+hf_xet/hf_xet.abi3.so,sha256=pOQAWIYPOtTKmwGT1HtH4Oe_jKflrgc1aWJ0xsTBcGs,11274016
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..245ec14d8785f19b20047cc664d0fc1e3a44da90
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/WHEEL
@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: maturin (1.15.0)
+Root-Is-Purelib: false
+Tag: cp38-abi3-manylinux_2_17_x86_64
+Tag: cp38-abi3-manylinux2014_x86_64
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/licenses/LICENSE b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/licenses/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/sboms/hf_xet.cyclonedx.json b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/sboms/hf_xet.cyclonedx.json
new file mode 100644
index 0000000000000000000000000000000000000000..4e289c5a3992583f6b46f8eaae3ff541fb1f05a5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet-1.7.0.dist-info/sboms/hf_xet.cyclonedx.json
@@ -0,0 +1,8653 @@
+{
+  "bomFormat": "CycloneDX",
+  "specVersion": "1.5",
+  "version": 1,
+  "serialNumber": "urn:uuid:582a1c38-a435-404b-a0ca-464841810196",
+  "metadata": {
+    "timestamp": "2026-10-06T19:59:57.776479605Z",
+    "tools": [
+      {
+        "vendor": "CycloneDX",
+        "name": "cargo-cyclonedx",
+        "version": "0.5.9"
+      }
+    ],
+    "component": {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/hf_xet#1.7.0",
+      "name": "hf_xet",
+      "version": "1.7.0",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/hf_xet@1.7.0?download_url=file://.",
+      "components": [
+        {
+          "type": "library",
+          "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/hf_xet#1.7.0 bin-target-0",
+          "name": "hf_xet",
+          "version": "1.7.0",
+          "purl": "pkg:cargo/hf_xet@1.7.0?download_url=file://.#src/lib.rs"
+        }
+      ]
+    },
+    "properties": [
+      {
+        "name": "cdx:rustc:sbom:target:all_targets",
+        "value": "true"
+      }
+    ]
+  },
+  "components": [
+    {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/xet_client#xet-client@1.7.0",
+      "name": "xet-client",
+      "version": "1.7.0",
+      "description": "Client library for communicating with Hugging Face Xet storage servers.  Use through the hf-xet crate.",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/xet-client@1.7.0?download_url=file:///home/runner/work/xet-core/xet-core/xet_client",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/huggingface/xet-core"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/huggingface/xet-core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/xet_core_structures#xet-core-structures@1.7.0",
+      "name": "xet-core-structures",
+      "version": "1.7.0",
+      "description": "Core data structures including MerkleHash, metadata shards, and Xorb objects.",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/xet-core-structures@1.7.0?download_url=file:///home/runner/work/xet-core/xet-core/xet_core_structures",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/huggingface/xet-core"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/huggingface/xet-core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/xet_data#xet-data@1.7.0",
+      "name": "xet-data",
+      "version": "1.7.0",
+      "description": "Data processing pipeline for chunking, deduplication, and file reconstruction; used in the Hugging Face Xet client tools.  Intended to be used through the API in the hf-xet package.",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/xet-data@1.7.0?download_url=file:///home/runner/work/xet-core/xet-core/xet_data",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/huggingface/xet-core"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/huggingface/xet-core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/xet_pkg#hf-xet@1.7.0",
+      "name": "hf-xet",
+      "version": "1.7.0",
+      "description": "Client library and tooling for the Hugging Face Xet data storage system.",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/hf-xet@1.7.0?download_url=file:///home/runner/work/xet-core/xet-core/xet_pkg",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/huggingface/xet-core"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/huggingface/xet-core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0",
+      "name": "xet-runtime",
+      "version": "1.7.0",
+      "description": "Async runtime, configuration, logging, and utility infrastructure for the Hugging Face Xet client tools.",
+      "scope": "required",
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/xet-runtime@1.7.0?download_url=file:///home/runner/work/xet-core/xet-core/xet_runtime",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/huggingface/xet-core"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/huggingface/xet-core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.4",
+      "author": "Andrew Gallant <jamslam@gmail.com>",
+      "name": "aho-corasick",
+      "version": "1.1.4",
+      "description": "Fast multiple substring searching.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unlicense OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/aho-corasick@1.1.4",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/BurntSushi/aho-corasick"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/BurntSushi/aho-corasick"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "anyhow",
+      "version": "1.0.103",
+      "description": "Flexible concrete Error type built on std::error::Error",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/anyhow@1.0.103",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/anyhow"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/anyhow"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#approx@0.5.1",
+      "author": "Brendan Zabarauskas <bjzaba@yahoo.com.au>",
+      "name": "approx",
+      "version": "0.5.1",
+      "description": "Approximate floating point equality comparisons and assertions.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/approx@0.5.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/approx"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/brendanzab/approx"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/brendanzab/approx"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#arrayref@0.3.9",
+      "author": "David Roundy <roundyd@physics.oregonstate.edu>",
+      "name": "arrayref",
+      "version": "0.3.9",
+      "description": "Macros to take array references of slices",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "BSD-2-Clause"
+        }
+      ],
+      "purl": "pkg:cargo/arrayref@0.3.9",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/arrayref"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/droundy/arrayref"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#arrayvec@0.7.6",
+      "author": "bluss",
+      "name": "arrayvec",
+      "version": "0.7.6",
+      "description": "A vector with fixed capacity, backed by an array (it can be stored on the stack too). Implements fixed capacity ArrayVec and ArrayString.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/arrayvec@0.7.6",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/arrayvec/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/bluss/arrayvec"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "async-trait",
+      "version": "0.1.89",
+      "description": "Type erasure for async trait methods",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/async-trait@0.1.89",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/async-trait"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/async-trait"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#atomic-waker@1.1.2",
+      "author": "Stjepan Glavina <stjepang@gmail.com>, Contributors to futures-rs",
+      "name": "atomic-waker",
+      "version": "1.1.2",
+      "description": "A synchronization primitive for task wakeup",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/atomic-waker@1.1.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/smol-rs/atomic-waker"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#autocfg@1.5.0",
+      "author": "Josh Stone <cuviper@gmail.com>",
+      "name": "autocfg",
+      "version": "1.5.0",
+      "description": "Automatic cfg for Rust compiler features",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/autocfg@1.5.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/autocfg/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/cuviper/autocfg"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#aws-lc-rs@1.18.1",
+      "author": "AWS-LibCrypto",
+      "name": "aws-lc-rs",
+      "version": "1.18.1",
+      "description": "aws-lc-rs is a cryptographic library using AWS-LC for its cryptographic operations. This library strives to be API-compatible with the popular Rust library named ring.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b281d307588d634de920874890732659e2e7672f72b5e10e81badc1a8a83621e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "ISC AND (Apache-2.0 OR ISC)"
+        }
+      ],
+      "purl": "pkg:cargo/aws-lc-rs@1.18.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/crate/aws-lc-rs"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/aws/aws-lc-rs"
+        },
+        {
+          "type": "other",
+          "url": "aws_lc_rs_1_18_1_sys"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/aws/aws-lc-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#aws-lc-sys@0.45.0",
+      "author": "AWS-LC",
+      "name": "aws-lc-sys",
+      "version": "0.45.0",
+      "description": "AWS-LC is a general-purpose cryptographic library maintained by the AWS Cryptography team for AWS and their customers. It іs based on code from the Google BoringSSL project and the OpenSSL project.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9bff6c3b54fad79a2e60b8102caf565819711497c1f5f092f49508e2f5c31b27"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "ISC AND (Apache-2.0 OR ISC) AND Apache-2.0 AND MIT AND BSD-3-Clause AND (Apache-2.0 OR ISC OR MIT) AND (Apache-2.0 OR ISC OR MIT-0)"
+        }
+      ],
+      "purl": "pkg:cargo/aws-lc-sys@0.45.0",
+      "externalReferences": [
+        {
+          "type": "other",
+          "url": "aws_lc_0_45_0"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/aws/aws-lc-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1",
+      "author": "Marshall Pierce <marshall@mpierce.org>",
+      "name": "base64",
+      "version": "0.22.1",
+      "description": "encodes and decodes base64 as bytes or utf8",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/base64@0.22.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/base64"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/marshallpierce/rust-base64"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#bitflags@2.11.0",
+      "author": "The Rust Project Developers",
+      "name": "bitflags",
+      "version": "2.11.0",
+      "description": "A macro to generate structures which behave like bitflags. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/bitflags@2.11.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/bitflags"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/bitflags/bitflags"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/bitflags/bitflags"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#blake3@1.8.3",
+      "author": "Jack O'Connor <oconnor663@gmail.com>, Samuel Neves",
+      "name": "blake3",
+      "version": "1.8.3",
+      "description": "the BLAKE3 hash function",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "CC0-1.0 OR Apache-2.0 OR Apache-2.0 WITH LLVM-exception"
+        }
+      ],
+      "purl": "pkg:cargo/blake3@1.8.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/blake3"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/BLAKE3-team/BLAKE3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#block-buffer@0.12.1",
+      "author": "RustCrypto Developers",
+      "name": "block-buffer",
+      "version": "0.12.1",
+      "description": "Buffer types for block processing of data",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/block-buffer@0.12.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/block-buffer"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/utils"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#bstr@1.12.1",
+      "author": "Andrew Gallant <jamslam@gmail.com>",
+      "name": "bstr",
+      "version": "1.12.1",
+      "description": "A string type that is not required to be valid UTF-8.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/bstr@1.12.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/bstr"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/BurntSushi/bstr"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/BurntSushi/bstr"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#bytemuck@1.25.0",
+      "author": "Lokathor <zefria@gmail.com>",
+      "name": "bytemuck",
+      "version": "1.25.0",
+      "description": "A crate for mucking around with piles of bytes.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib OR Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/bytemuck@1.25.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/Lokathor/bytemuck"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+      "author": "Carl Lerche <me@carllerche.com>, Sean McArthur <sean@seanmonstar.com>",
+      "name": "bytes",
+      "version": "1.11.1",
+      "description": "Types and traits for working with bytes",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/bytes@1.11.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/bytes"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "cc",
+      "version": "1.2.57",
+      "description": "A build-time dependency for Cargo build scripts to assist in invoking the native C compiler to compile native C code into a static archive to be linked into Rust code. ",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7a0dd1ca384932ff3641c8718a02769f1698e7563dc6974ffd03346116310423"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cc@1.2.57",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cc"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/cc-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/cc-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cfg-if@0.1.10",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "cfg-if",
+      "version": "0.1.10",
+      "description": "A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cfg-if@0.1.10",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cfg-if"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/alexcrichton/cfg-if"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/alexcrichton/cfg-if"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "cfg-if",
+      "version": "1.0.4",
+      "description": "A macro to ergonomically define an item depending on a large number of #[cfg] parameters. Structured like an if-else chain, the first matching branch is the item that gets emitted. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cfg-if@1.0.4",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/cfg-if"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cfg_aliases@0.2.1",
+      "author": "Zicklag <zicklag@katharostech.com>",
+      "name": "cfg_aliases",
+      "version": "0.2.1",
+      "description": "A tiny utility to help save you a lot of effort with long winded `#[cfg()]` checks.",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "613afe47fcd5fac7ccf1db93babcb082c5994d996f20b8b159f2ad1658eb5724"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/cfg_aliases@0.2.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cfg_aliases"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/katharostech/cfg_aliases"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/katharostech/cfg_aliases"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#chacha20@0.10.2",
+      "author": "RustCrypto Developers",
+      "name": "chacha20",
+      "version": "0.10.2",
+      "description": "The ChaCha20 stream cipher (RFC 8439) implemented in pure Rust using traits from the RustCrypto `cipher` crate, with optional architecture-specific hardware acceleration (AVX2, SSE2). Additionally provides the ChaCha8, ChaCha12, XChaCha20, XChaCha12 and XChaCha8 stream ciphers, and also optional rand_core-compatible RNGs based on those ciphers. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "65c35e4b699c7e15ccbe7ee35c005e4fc0a278d22238a2857e6ce2dadeda1b06"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/chacha20@0.10.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/chacha20"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/stream-ciphers"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.44",
+      "name": "chrono",
+      "version": "0.4.44",
+      "description": "Date and time library for Rust",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/chrono@0.4.44",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/chrono/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/chronotope/chrono"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/chronotope/chrono"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cmake@0.1.57",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "cmake",
+      "version": "0.1.57",
+      "description": "A build dependency for running `cmake` to build a native library ",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "75443c44cd6b379beb8c5b45d85d0773baf31cce901fe7bb252f4eff3008ef7d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cmake@0.1.57",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cmake"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/cmake-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/cmake-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#colored@3.1.1",
+      "author": "Thomas Wickham <mackwic@gmail.com>",
+      "name": "colored",
+      "version": "3.1.1",
+      "description": "The most simple way to add colors in your terminal",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MPL-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/colored@3.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/mackwic/colored"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/mackwic/colored"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#const-oid@0.10.2",
+      "author": "RustCrypto Developers",
+      "name": "const-oid",
+      "version": "0.10.2",
+      "description": "Const-friendly implementation of the ISO/IEC Object Identifier (OID) standard as defined in ITU X.660, with support for BER/DER encoding/decoding as well as heapless no_std (i.e. embedded) support ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a6ef517f0926dd24a1582492c791b6a4818a4d94e789a334894aa15b0d12f55c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/const-oid@0.10.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/const-oid"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/RustCrypto/formats/tree/master/const-oid"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/formats"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#const-str@1.1.0",
+      "author": "Nugine <nugine@foxmail.com>",
+      "name": "const-str",
+      "version": "1.1.0",
+      "description": "compile-time string operations",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "18f12cc9948ed9604230cdddc7c86e270f9401ccbe3c2e98a4378c5e7632212f"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/const-str@1.1.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/Nugine/const-str"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#const_panic@0.2.15",
+      "author": "rodrimati1992 <rodrimatt1985@gmail.com>",
+      "name": "const_panic",
+      "version": "0.2.15",
+      "description": "const panic with formatting",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e262cdaac42494e3ae34c43969f9cdeb7da178bdb4b66fa6a1ea2edb4c8ae652"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/const_panic@0.2.15",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rodrimati1992/const_panic/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#constant_time_eq@0.4.2",
+      "author": "Cesar Eduardo Barros <cesarb@cesarb.eti.br>",
+      "name": "constant_time_eq",
+      "version": "0.4.2",
+      "description": "Compares two equal-sized byte strings in constant time.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "CC0-1.0 OR MIT-0 OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/constant_time_eq@0.4.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/constant_time_eq"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/cesarb/constant_time_eq"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#countio@0.3.0",
+      "author": "Oleh Martsokha <o.martsokha@gmail.com>",
+      "name": "countio",
+      "version": "0.3.0",
+      "description": "Byte counting for std::io::{Read, Write, Seek} and its async variants from futures and tokio. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b9702aee5d1d744c01d82f6915644f950f898e014903385464c773b96fefdecb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/countio@0.3.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/countio"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/spire-rs/countio"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/spire-rs/countio"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.2.17",
+      "author": "RustCrypto Developers",
+      "name": "cpufeatures",
+      "version": "0.2.17",
+      "description": "Lightweight runtime CPU feature detection for aarch64, loongarch64, and x86/x86_64 targets,  with no_std support and support for mobile targets including Android and iOS ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cpufeatures@0.2.17",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cpufeatures"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/utils"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.3.0",
+      "author": "RustCrypto Developers",
+      "name": "cpufeatures",
+      "version": "0.3.0",
+      "description": "Lightweight runtime CPU feature detection for aarch64, loongarch64, and x86/x86_64 targets, with no_std support and support for mobile targets including Android and iOS ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8b2a41393f66f16b0823bb79094d54ac5fbd34ab292ddafb9a0456ac9f87d201"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/cpufeatures@0.3.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/cpufeatures"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/utils"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0",
+      "author": "Sam Rijs <srijs@airpost.net>, Alex Crichton <alex@alexcrichton.com>",
+      "name": "crc32fast",
+      "version": "1.5.0",
+      "description": "Fast, SIMD-accelerated CRC32 (IEEE) checksum computation",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/crc32fast@1.5.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/srijs/rust-crc32fast"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#crossbeam-channel@0.5.15",
+      "name": "crossbeam-channel",
+      "version": "0.5.15",
+      "description": "Multi-producer multi-consumer channels for message passing",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/crossbeam-channel@0.5.15",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-channel"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/crossbeam-rs/crossbeam"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21",
+      "name": "crossbeam-utils",
+      "version": "0.8.21",
+      "description": "Utilities for concurrent programming",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/crossbeam-utils@0.8.21",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/crossbeam-rs/crossbeam/tree/master/crossbeam-utils"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/crossbeam-rs/crossbeam"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#crypto-common@0.2.2",
+      "author": "RustCrypto Developers",
+      "name": "crypto-common",
+      "version": "0.2.2",
+      "description": "Common traits used by cryptographic algorithms",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/crypto-common@0.2.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/crypto-common"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/traits"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#ctor@1.0.3",
+      "author": "Matt Mastracci <matthew@mastracci.com>",
+      "name": "ctor",
+      "version": "1.0.3",
+      "description": "Global, no_std-compatible constructors for all platforms that run before main (like C/C++ __attribute__((constructor)))",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5c24d2b2b7c12a2fffb7c5c8fd0dcda7ca14b4600fa2d3701b6079aefb6fa180"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/ctor@1.0.3",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/mmastrac/linktime"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#deranged@0.5.8",
+      "author": "Jacob Pratt <jacob@jhpratt.dev>",
+      "name": "deranged",
+      "version": "0.5.8",
+      "description": "Ranged integers",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/deranged@0.5.8",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/jhpratt/deranged"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#digest@0.11.3",
+      "author": "RustCrypto Developers",
+      "name": "digest",
+      "version": "0.11.3",
+      "description": "Traits for cryptographic hash functions and message authentication codes",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/digest@0.11.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/digest"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/traits"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#dirs-sys@0.5.0",
+      "author": "Simon Ochsenreither <simon@ochsenreither.de>",
+      "name": "dirs-sys",
+      "version": "0.5.0",
+      "description": "System-level helper functions for the dirs and directories crates.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/dirs-sys@0.5.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/dirs-dev/dirs-sys-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#dirs@6.0.0",
+      "author": "Simon Ochsenreither <simon@ochsenreither.de>",
+      "name": "dirs",
+      "version": "6.0.0",
+      "description": "A tiny low-level library that provides platform-specific standard locations of directories for config, cache and other data on Linux, Windows, macOS and Redox by leveraging the mechanisms defined by the XDG base/user directory specifications on Linux, the Known Folder API on Windows, and the Standard Directory guidelines on macOS.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/dirs@6.0.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/soc/dirs-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+      "author": "Jane Lusby <jlusby@yaah.dev>",
+      "name": "displaydoc",
+      "version": "0.2.5",
+      "description": "A derive macro for implementing the display Trait via a doc comment and string interpolation ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/displaydoc@0.2.5",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/displaydoc"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/yaahc/displaydoc"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/yaahc/displaydoc"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#dunce@1.0.5",
+      "author": "Kornel <kornel@geekhood.net>",
+      "name": "dunce",
+      "version": "1.0.5",
+      "description": "Normalize Windows paths to the most compatible format, avoiding UNC where possible",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "CC0-1.0 OR MIT-0 OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/dunce@1.0.5",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/dunce"
+        },
+        {
+          "type": "website",
+          "url": "https://lib.rs/crates/dunce"
+        },
+        {
+          "type": "vcs",
+          "url": "https://gitlab.com/kornelski/dunce"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#either@1.15.0",
+      "author": "bluss",
+      "name": "either",
+      "version": "1.15.0",
+      "description": "The enum `Either` with variants `Left` and `Right` is a general purpose sum type with two cases. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/either@1.15.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/either/1/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rayon-rs/either"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#errno@0.3.14",
+      "author": "Chris Wong <lambda.fairy@gmail.com>, Dan Gohman <dev@sunfishcode.online>",
+      "name": "errno",
+      "version": "0.3.14",
+      "description": "Cross-platform interface to the `errno` variable.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/errno@0.3.14",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/errno"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/lambda-fairy/rust-errno"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#fastrand@2.3.0",
+      "author": "Stjepan Glavina <stjepang@gmail.com>",
+      "name": "fastrand",
+      "version": "2.3.0",
+      "description": "A simple and fast random number generator",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/fastrand@2.3.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/smol-rs/fastrand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#find-msvc-tools@0.1.9",
+      "name": "find-msvc-tools",
+      "version": "0.1.9",
+      "description": "Find windows-specific tools, read MSVC versions from the registry and from COM interfaces",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/find-msvc-tools@0.1.9",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/find-msvc-tools"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/cc-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#form_urlencoded@1.2.2",
+      "author": "The rust-url developers",
+      "name": "form_urlencoded",
+      "version": "1.2.2",
+      "description": "Parser and serializer for the application/x-www-form-urlencoded syntax, as used by HTML forms.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/form_urlencoded@1.2.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/servo/rust-url"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#fs_extra@1.3.0",
+      "author": "Denis Kurilenko <webdesus@gmail.com>",
+      "name": "fs_extra",
+      "version": "1.3.0",
+      "description": "Expanding std::fs and std::io. Recursively copy folders with information about process and much more.",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/fs_extra@1.3.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/fs_extra"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/webdesus/fs_extra"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/webdesus/fs_extra"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+      "name": "futures-channel",
+      "version": "0.3.32",
+      "description": "Channels for asynchronous communication using futures-rs. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-channel@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+      "name": "futures-core",
+      "version": "0.3.32",
+      "description": "The core traits and types in for the `futures` library. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-core@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-executor@0.3.32",
+      "name": "futures-executor",
+      "version": "0.3.32",
+      "description": "Executors for asynchronous tasks based on the futures-rs library. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-executor@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.32",
+      "name": "futures-io",
+      "version": "0.3.32",
+      "description": "The `AsyncRead`, `AsyncWrite`, `AsyncSeek`, and `AsyncBufRead` traits for the futures-rs library. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-io@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-macro@0.3.32",
+      "name": "futures-macro",
+      "version": "0.3.32",
+      "description": "The futures-rs procedural macro implementations. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-macro@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32",
+      "name": "futures-sink",
+      "version": "0.3.32",
+      "description": "The asynchronous `Sink` trait for the futures-rs library. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-sink@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.32",
+      "name": "futures-task",
+      "version": "0.3.32",
+      "description": "Tools for working with tasks. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-task@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+      "name": "futures-util",
+      "version": "0.3.32",
+      "description": "Common utilities and extension traits for the futures-rs library. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures-util@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#futures@0.3.32",
+      "name": "futures",
+      "version": "0.3.32",
+      "description": "An implementation of futures and streams featuring zero allocations, composability, and iterator-like interfaces. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/futures@0.3.32",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://rust-lang.github.io/futures-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/futures-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#gearhash@0.1.3",
+      "author": "Sam Rijs <srijs@airpost.net>",
+      "name": "gearhash",
+      "version": "0.1.3",
+      "description": "Fast, SIMD-accelerated hash function for content-defined chunking",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c8cf82cf76cd16485e56295a1377c775ce708c9f1a0be6b029076d60a245d213"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/gearhash@0.1.3",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/srijs/rust-gearhash"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.2.17",
+      "author": "The Rand Project Developers",
+      "name": "getrandom",
+      "version": "0.2.17",
+      "description": "A small cross-platform library for retrieving random data from system source",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/getrandom@0.2.17",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/getrandom"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/getrandom"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4",
+      "author": "The Rand Project Developers",
+      "name": "getrandom",
+      "version": "0.3.4",
+      "description": "A small cross-platform library for retrieving random data from system source",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/getrandom@0.3.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/getrandom"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/getrandom"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.4.2",
+      "author": "The Rand Project Developers",
+      "name": "getrandom",
+      "version": "0.4.2",
+      "description": "A small cross-platform library for retrieving random data from system source",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/getrandom@0.4.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/getrandom"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/getrandom"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#git-version-macro@0.3.9",
+      "author": "David Roundy <daveroundy@gmail.com>, Maarten de Vries <maarten@de-vri.es>, Mara Bos <m-ou.se@m-ou.se>",
+      "name": "git-version-macro",
+      "version": "0.3.9",
+      "description": "Internal macro crate for git-version.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "53010ccb100b96a67bc32c0175f0ed1426b31b655d562898e57325f81c023ac0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "BSD-2-Clause"
+        }
+      ],
+      "purl": "pkg:cargo/git-version-macro@0.3.9",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/fusion-engineering/rust-git-version"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#git-version@0.3.9",
+      "author": "Mara Bos <m-ou.se@m-ou.se>, Maarten de Vries <maarten@de-vri.es>, David Roundy <daveroundy@gmail.com>",
+      "name": "git-version",
+      "version": "0.3.9",
+      "description": "Compile the git version (tag name, or hash otherwise) and dirty state into your program.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1ad568aa3db0fcbc81f2f116137f263d7304f512a1209b35b85150d3ef88ad19"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "BSD-2-Clause"
+        }
+      ],
+      "purl": "pkg:cargo/git-version@0.3.9",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/git-version/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/fusion-engineering/rust-git-version"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#heapify@0.2.0",
+      "name": "heapify",
+      "version": "0.2.0",
+      "description": "Convenience functions to turn slices into max-heaps.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0049b265b7f201ca9ab25475b22b47fe444060126a51abe00f77d986fc5cc52e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/heapify@0.2.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/ethereal-sheep/heapify"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#heck@0.5.0",
+      "name": "heck",
+      "version": "0.5.0",
+      "description": "heck is a case conversion library.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/heck@0.5.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/withoutboats/heck"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#http-body-util@0.1.3",
+      "author": "Carl Lerche <me@carllerche.com>, Lucio Franco <luciofranco14@gmail.com>, Sean McArthur <sean@seanmonstar.com>",
+      "name": "http-body-util",
+      "version": "0.1.3",
+      "description": "Combinators and adapters for HTTP request or response bodies. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b021d93e26becf5dc7e1b75b1bed1fd93124b374ceb73f43d4d4eafec896a64a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/http-body-util@0.1.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/http-body-util"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hyperium/http-body"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+      "author": "Carl Lerche <me@carllerche.com>, Lucio Franco <luciofranco14@gmail.com>, Sean McArthur <sean@seanmonstar.com>",
+      "name": "http-body",
+      "version": "1.0.1",
+      "description": "Trait representing an asynchronous, streaming, HTTP request or response body. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1efedce1fb8e6913f23e0c92de8e62cd5b772a67e7b3946df930a62566c93184"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/http-body@1.0.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/http-body"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hyperium/http-body"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+      "author": "Alex Crichton <alex@alexcrichton.com>, Carl Lerche <me@carllerche.com>, Sean McArthur <sean@seanmonstar.com>",
+      "name": "http",
+      "version": "1.4.0",
+      "description": "A set of types for representing HTTP requests and responses. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/http@1.4.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/http"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hyperium/http"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "httparse",
+      "version": "1.10.1",
+      "description": "A tiny, safe, speedy, zero-copy HTTP/1.x parser.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/httparse@1.10.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/httparse"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/seanmonstar/httparse"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#humantime@2.3.0",
+      "name": "humantime",
+      "version": "2.3.0",
+      "description": "A parser and formatter for std::time::{Duration, SystemTime}",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/humantime@2.3.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/humantime"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/chronotope/humantime"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/chronotope/humantime"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#hybrid-array@0.4.13",
+      "author": "RustCrypto Developers",
+      "name": "hybrid-array",
+      "version": "0.4.13",
+      "description": "Hybrid typenum-based and const generic array types designed to provide the flexibility of typenum-based expressions while also allowing interoperability and a transition path to const generics ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "818356c5132c1fede50f837ca96afbe78ff42413047f4abb886217845e1b6c8c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/hybrid-array@0.4.13",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/hybrid-array"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/hybrid-array"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#hyper-rustls@0.27.7",
+      "name": "hyper-rustls",
+      "version": "0.27.7",
+      "description": "Rustls+hyper integration for pure rust HTTPS",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e3c93eb611681b207e1fe55d5a71ecf91572ec8a6705cdb6857f7d8d5242cf58"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR ISC OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/hyper-rustls@0.27.7",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/hyper-rustls/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/hyper-rustls"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/hyper-rustls"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#hyper-util@0.1.20",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "hyper-util",
+      "version": "0.1.20",
+      "description": "hyper utilities",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "96547c2556ec9d12fb1578c4eaf448b04993e7fb79cbaad930a656880a6bdfa0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/hyper-util@0.1.20",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/hyper-util"
+        },
+        {
+          "type": "website",
+          "url": "https://hyper.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hyperium/hyper-util"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "hyper",
+      "version": "1.8.1",
+      "description": "A protective and efficient HTTP library for all.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2ab2d4f250c3d7b1c9fcdff1cece94ea4e2dfbec68614f7b87cb205f24ca9d11"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/hyper@1.8.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/hyper"
+        },
+        {
+          "type": "website",
+          "url": "https://hyper.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hyperium/hyper"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#iana-time-zone@0.1.65",
+      "author": "Andrew Straw <strawman@astraw.com>, René Kijewski <rene.kijewski@fu-berlin.de>, Ryan Lopopolo <rjl@hyperbo.la>",
+      "name": "iana-time-zone",
+      "version": "0.1.65",
+      "description": "get the IANA time zone for the current system",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/iana-time-zone@0.1.65",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/strawlab/iana-time-zone"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.1.1",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_collections",
+      "version": "2.1.1",
+      "description": "Collection of API for use in ICU libraries.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_collections@2.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.1.1",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_locale_core",
+      "version": "2.1.1",
+      "description": "API for managing Unicode Language and Locale Identifiers",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_locale_core@2.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer@2.1.1",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_normalizer",
+      "version": "2.1.1",
+      "description": "API for normalizing text into Unicode Normalization Forms",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_normalizer@2.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.1.1",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_normalizer_data",
+      "version": "2.1.1",
+      "description": "Data for the icu_normalizer crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_normalizer_data@2.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.1.2",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_properties",
+      "version": "2.1.2",
+      "description": "Definitions for Unicode properties",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_properties@2.1.2",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.1.2",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_properties_data",
+      "version": "2.1.2",
+      "description": "Data for the icu_properties crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_properties_data@2.1.2",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.1.1",
+      "author": "The ICU4X Project Developers",
+      "name": "icu_provider",
+      "version": "2.1.1",
+      "description": "Trait and struct definitions for the ICU data provider",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/icu_provider@2.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#idna@1.1.0",
+      "author": "The rust-url developers",
+      "name": "idna",
+      "version": "1.1.0",
+      "description": "IDNA (Internationalizing Domain Names in Applications) and Punycode.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/idna@1.1.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/servo/rust-url/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#idna_adapter@1.2.1",
+      "author": "The rust-url developers",
+      "name": "idna_adapter",
+      "version": "1.2.1",
+      "description": "Back end adapter for idna",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/idna_adapter@1.2.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/idna_adapter/latest/idna_adapter/"
+        },
+        {
+          "type": "website",
+          "url": "https://docs.rs/crate/idna_adapter/latest"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hsivonen/idna_adapter"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#inventory@0.3.22",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "inventory",
+      "version": "0.3.22",
+      "description": "Typed distributed plugin registration",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "009ae045c87e7082cb72dab0ccd01ae075dd00141ddc108f43a0ea150a9e7227"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/inventory@0.3.22",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/inventory"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/inventory"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#ipnet@2.12.0",
+      "author": "Kris Price <kris@krisprice.nz>",
+      "name": "ipnet",
+      "version": "2.12.0",
+      "description": "Provides types and useful methods for working with IPv4 and IPv6 network addresses, commonly called IP prefixes. The new `IpNet`, `Ipv4Net`, and `Ipv6Net` types build on the existing `IpAddr`, `Ipv4Addr`, and `Ipv6Addr` types already provided in Rust's standard library and align to their design to stay consistent. The module also provides useful traits that extend `Ipv4Addr` and `Ipv6Addr` with methods for `Add`, `Sub`, `BitAnd`, and `BitOr` operations. The module only uses stable feature so it is guaranteed to compile using the stable toolchain.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d98f6fed1fde3f8c21bc40a1abb88dd75e67924f9cffc3ef95607bad8017f8e2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/ipnet@2.12.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/ipnet"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/krisprice/ipnet"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#iri-string@0.7.11",
+      "author": "YOSHIOKA Takuma <nop_thread@nops.red>",
+      "name": "iri-string",
+      "version": "0.7.11",
+      "description": "IRI as string types",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d8e7418f59cc01c88316161279a7f665217ae316b388e58a0d10e29f54f1e5eb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/iri-string@0.7.11",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/lo48576/iri-string"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0",
+      "author": "bluss",
+      "name": "itertools",
+      "version": "0.14.0",
+      "description": "Extra iterator adaptors, iterator methods, free functions, and macros.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/itertools@0.14.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/itertools/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-itertools/itertools"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "itoa",
+      "version": "1.0.18",
+      "description": "Fast integer primitive to string conversion",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/itoa@1.0.18",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/itoa"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/itoa"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#jobserver@0.1.34",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "jobserver",
+      "version": "0.1.34",
+      "description": "An implementation of the GNU Make jobserver for Rust. ",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/jobserver@0.1.34",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/jobserver"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/jobserver-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/jobserver-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#konst@0.4.3",
+      "author": "rodrimati1992 <rodrimatt1985@gmail.com>",
+      "name": "konst",
+      "version": "0.4.3",
+      "description": "Const equivalents of std features: comparison, destructuring, iteration, and parsing",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f660d5f887e3562f9ab6f4a14988795b694099d66b4f5dedc02d197ba9becb1d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/konst@0.4.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/konst/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rodrimati1992/konst/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#konst_proc_macros@0.4.1",
+      "author": "rodrimati1992 <rodrimatt1985@gmail.com>",
+      "name": "konst_proc_macros",
+      "version": "0.4.1",
+      "description": "Implementation detail of the `konst` crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e037a2e1d8d5fdbd49b16a4ea09d5d6401c1f29eca5ff29d03d3824dba16256a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/konst_proc_macros@0.4.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/konst/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rodrimati1992/konst/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#lazy_static@1.5.0",
+      "author": "Marvin Löbel <loebel.marvin@gmail.com>",
+      "name": "lazy_static",
+      "version": "1.5.0",
+      "description": "A macro for declaring lazily evaluated statics in Rust.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/lazy_static@1.5.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/lazy_static"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang-nursery/lazy-static.rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+      "author": "The Rust Project Developers",
+      "name": "libc",
+      "version": "0.2.183",
+      "description": "Raw FFI bindings to platform libraries like libc.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/libc@0.2.183",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/libc"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#link-section@0.15.0",
+      "author": "Matt Mastracci <matthew@mastracci.com>",
+      "name": "link-section",
+      "version": "0.15.0",
+      "description": "Link-time initialized slices for Rust, with full support for Linux, macOS, Windows, WASM and many more platforms.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4641b91711debb59c61b07eb5e30521ed6d9e2bdd9fd04f934e7da3a5bc386d4"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/link-section@0.15.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/mmastrac/linktime"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#linktime-proc-macro@0.1.0",
+      "author": "Matt Mastracci <matthew@mastracci.com>",
+      "name": "linktime-proc-macro",
+      "version": "0.1.0",
+      "description": "proc-macro support for the linktime crates",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a44cd706ff0d503ee32b2071166510ca27e281228de10cd3aa8d35ff94560f81"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/linktime-proc-macro@0.1.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/mmastrac/rust-ctor"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#linux-raw-sys@0.12.1",
+      "author": "Dan Gohman <dev@sunfishcode.online>",
+      "name": "linux-raw-sys",
+      "version": "0.12.1",
+      "description": "Generated bindings for Linux's userspace API",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/linux-raw-sys@0.12.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/linux-raw-sys"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/sunfishcode/linux-raw-sys"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#litemap@0.8.1",
+      "author": "The ICU4X Project Developers",
+      "name": "litemap",
+      "version": "0.8.1",
+      "description": "A key-value Map implementation based on a flat, sorted Vec.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/litemap@0.8.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/litemap"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#log@0.4.29",
+      "author": "The Rust Project Developers",
+      "name": "log",
+      "version": "0.4.29",
+      "description": "A lightweight logging facade for Rust ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/log@0.4.29",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/log"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/log"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#lru-slab@0.1.2",
+      "author": "Benjamin Saunders <ben.e.saunders@gmail.com>",
+      "name": "lru-slab",
+      "version": "0.1.2",
+      "description": "Pre-allocated storage with constant-time LRU tracking",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "112b39cec0b298b6c1999fee3e31427f74f676e4cb9879ed1a121b43661a4154"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0 OR Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/lru-slab@0.1.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/Ralith/lru-slab"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#lz4_flex@0.13.0",
+      "author": "Pascal Seitz <pascal.seitz@gmail.com>, Arthur Silva <arthurprs@gmail.com>, ticki <Ticki@users.noreply.github.com>",
+      "name": "lz4_flex",
+      "version": "0.13.0",
+      "description": "Fastest LZ4 implementation in Rust, no unsafe by default.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "db9a0d582c2874f68138a16ce1867e0ffde6c0bb0a0df85e1f36d04146db488a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/lz4_flex@0.13.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/pseitz/lz4_flex"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pseitz/lz4_flex"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#matchers@0.2.0",
+      "author": "Eliza Weisman <eliza@buoyant.io>",
+      "name": "matchers",
+      "version": "0.2.0",
+      "description": "Regex matching on character and byte streams. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/matchers@0.2.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/matchers/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/hawkw/matchers"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hawkw/matchers"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+      "author": "Andrew Gallant <jamslam@gmail.com>, bluss",
+      "name": "memchr",
+      "version": "2.8.0",
+      "description": "Provides extremely fast (uses SIMD on x86_64, aarch64 and wasm32) routines for 1, 2 or 3 byte search and single substring search. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unlicense OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/memchr@2.8.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/memchr/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/BurntSushi/memchr"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/BurntSushi/memchr"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#mio@1.1.1",
+      "author": "Carl Lerche <me@carllerche.com>, Thomas de Zeeuw <thomasdezeeuw@gmail.com>, Tokio Contributors <team@tokio.rs>",
+      "name": "mio",
+      "version": "1.1.1",
+      "description": "Lightweight non-blocking I/O.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/mio@1.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/tokio-rs/mio"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/mio"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+      "author": "Thom Chiovoloni <chiovolonit@gmail.com>",
+      "name": "more-asserts",
+      "version": "0.3.1",
+      "description": "Small library providing additional assert_* and debug_assert_* macros.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1fafa6961cabd9c63bcd77a45d7e3b7f3b552b70417831fb0f56db717e72407e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unlicense OR MIT OR Apache-2.0 OR CC0-1.0"
+        }
+      ],
+      "purl": "pkg:cargo/more-asserts@0.3.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/more-asserts"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/thomcc/rust-more-asserts"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/thomcc/rust-more-asserts"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#nu-ansi-term@0.50.3",
+      "author": "ogham@bsago.me, Ryan Scheel (Havvy) <ryan.havvy@gmail.com>, Josh Triplett <josh@joshtriplett.org>, The Nushell Project Developers",
+      "name": "nu-ansi-term",
+      "version": "0.50.3",
+      "description": "Library for ANSI terminal colors and styles (bold, underline)",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/nu-ansi-term@0.50.3",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/nushell/nu-ansi-term"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#num-conv@0.2.0",
+      "author": "Jacob Pratt <jacob@jhpratt.dev>",
+      "name": "num-conv",
+      "version": "0.2.0",
+      "description": "`num_conv` is a crate to convert between integer types without using `as` casts. This provides better certainty when refactoring, makes the exact behavior of code more explicit, and allows using turbofish syntax. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/num-conv@0.2.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/jhpratt/num-conv"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19",
+      "author": "The Rust Project Developers",
+      "name": "num-traits",
+      "version": "0.2.19",
+      "description": "Numeric traits for generic mathematics",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/num-traits@0.2.19",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/num-traits"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-num/num-traits"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-num/num-traits"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+      "author": "Aleksey Kladov <aleksey.kladov@gmail.com>",
+      "name": "once_cell",
+      "version": "1.21.4",
+      "description": "Single assignment cells and lazy values.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/once_cell@1.21.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/once_cell"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/matklad/once_cell"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#oneshot@0.1.13",
+      "author": "Linus Färnstrand <faern@faern.net>",
+      "name": "oneshot",
+      "version": "0.1.13",
+      "description": "Oneshot spsc channel with (potentially) lock-free non-blocking send, and a receiver supporting both thread blocking receive operations as well as Future based async polling. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "269bca4c2591a28585d6bf10d9ed0332b7d76900a1b02bec41bdc3a2cdcda107"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/oneshot@0.1.13",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/faern/oneshot"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#openssl-probe@0.2.1",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "openssl-probe",
+      "version": "0.2.1",
+      "description": "A library for helping to find system-wide trust anchor (\"root\") certificate locations based on paths typically used by `openssl`. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/openssl-probe@0.2.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/openssl-probe"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/openssl-probe"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#option-ext@0.2.0",
+      "author": "Simon Ochsenreither <simon@ochsenreither.de>",
+      "name": "option-ext",
+      "version": "0.2.0",
+      "description": "Extends `Option` with additional operations",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MPL-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/option-ext@0.2.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/option-ext/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/soc/option-ext"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/soc/option-ext.git"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#os_str_bytes@6.6.1",
+      "author": "dylni",
+      "name": "os_str_bytes",
+      "version": "6.6.1",
+      "description": "Convert between byte sequences and platform-native strings ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e2355d85b9a3786f481747ced0e0ff2ba35213a1f9bd406ed906554d7af805a1"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/os_str_bytes@6.6.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/dylni/os_str_bytes"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2",
+      "author": "The rust-url developers",
+      "name": "percent-encoding",
+      "version": "2.3.2",
+      "description": "Percent encoding and decoding",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/percent-encoding@2.3.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/servo/rust-url/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project-internal@1.1.11",
+      "name": "pin-project-internal",
+      "version": "1.1.11",
+      "description": "Implementation detail of the `pin-project` crate. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d9b20ed30f105399776b9c883e68e536ef602a16ae6f596d2c473591d6ad64c6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/pin-project-internal@1.1.11",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/taiki-e/pin-project"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+      "name": "pin-project-lite",
+      "version": "0.2.17",
+      "description": "A lightweight version of pin-project written with declarative macros. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a89322df9ebe1c1578d689c92318e070967d1042b512afbe49518723f4e6d5cd"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/pin-project-lite@0.2.17",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/taiki-e/pin-project-lite"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project@1.1.11",
+      "name": "pin-project",
+      "version": "1.1.11",
+      "description": "A crate for safe and ergonomic pin-projection. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f1749c7ed4bcaf4c3d0a3efc28538844fb29bcdd7d2b67b2be7e20ba861ff517"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/pin-project@1.1.11",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/taiki-e/pin-project"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pin-utils@0.1.0",
+      "author": "Josef Brandl <mail@josefbrandl.de>",
+      "name": "pin-utils",
+      "version": "0.1.0",
+      "description": "Utilities for pinning ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pin-utils@0.1.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/pin-utils"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang-nursery/pin-utils"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pkg-config@0.3.32",
+      "author": "Alex Crichton <alex@alexcrichton.com>",
+      "name": "pkg-config",
+      "version": "0.3.32",
+      "description": "A library to run the pkg-config system tool at build time in order to be used in Cargo build scripts. ",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pkg-config@0.3.32",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/pkg-config"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/pkg-config-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#potential_utf@0.1.4",
+      "author": "The ICU4X Project Developers",
+      "name": "potential_utf",
+      "version": "0.1.4",
+      "description": "Unvalidated string and character types",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/potential_utf@0.1.4",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#powerfmt@0.2.0",
+      "author": "Jacob Pratt <jacob@jhpratt.dev>",
+      "name": "powerfmt",
+      "version": "0.2.0",
+      "description": "    `powerfmt` is a library that provides utilities for formatting values. This crate makes it     significantly easier to support filling to a minimum width with alignment, avoid heap     allocation, and avoid repetitive calculations. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/powerfmt@0.2.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/jhpratt/powerfmt"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#ppv-lite86@0.2.21",
+      "author": "The CryptoCorrosion Contributors",
+      "name": "ppv-lite86",
+      "version": "0.2.21",
+      "description": "Cross-platform cryptography-oriented low-level SIMD library.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/ppv-lite86@0.2.21",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/cryptocorrosion/cryptocorrosion"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+      "author": "David Tolnay <dtolnay@gmail.com>, Alex Crichton <alex@alexcrichton.com>",
+      "name": "proc-macro2",
+      "version": "1.0.106",
+      "description": "A substitute implementation of the compiler's `proc_macro` API to decouple token-based libraries from the procedural macro use case.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/proc-macro2@1.0.106",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/proc-macro2"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/proc-macro2"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-build-config@0.29.0",
+      "author": "PyO3 Project and Contributors <https://github.com/PyO3>",
+      "name": "pyo3-build-config",
+      "version": "0.29.0",
+      "description": "Build configuration for the PyO3 ecosystem",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pyo3-build-config@0.29.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/pyo3/pyo3"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pyo3/pyo3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-ffi@0.29.0",
+      "author": "PyO3 Project and Contributors <https://github.com/PyO3>",
+      "name": "pyo3-ffi",
+      "version": "0.29.0",
+      "description": "Python-API bindings for the PyO3 ecosystem",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pyo3-ffi@0.29.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/pyo3/pyo3"
+        },
+        {
+          "type": "other",
+          "url": "python"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pyo3/pyo3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros-backend@0.29.0",
+      "author": "PyO3 Project and Contributors <https://github.com/PyO3>",
+      "name": "pyo3-macros-backend",
+      "version": "0.29.0",
+      "description": "Code generation for PyO3 package",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pyo3-macros-backend@0.29.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/pyo3/pyo3"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pyo3/pyo3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros@0.29.0",
+      "author": "PyO3 Project and Contributors <https://github.com/PyO3>",
+      "name": "pyo3-macros",
+      "version": "0.29.0",
+      "description": "Proc macros for PyO3 package",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pyo3-macros@0.29.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/pyo3/pyo3"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pyo3/pyo3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+      "author": "PyO3 Project and Contributors <https://github.com/PyO3>",
+      "name": "pyo3",
+      "version": "0.29.0",
+      "description": "Bindings to Python interpreter",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/pyo3@0.29.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/crate/pyo3/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/pyo3/pyo3"
+        },
+        {
+          "type": "other",
+          "url": "pyo3-python"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/pyo3/pyo3"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#quinn-proto@0.11.15",
+      "name": "quinn-proto",
+      "version": "0.11.15",
+      "description": "State machine for the QUIC transport protocol",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4fcb935c5bec503c2f0e306bdd3e58bb9029dcb14fa8d9ac76e3a5256ac0763e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/quinn-proto@0.11.15",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/quinn-rs/quinn"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#quinn-udp@0.5.14",
+      "name": "quinn-udp",
+      "version": "0.5.14",
+      "description": "UDP sockets with ECN information for the QUIC transport protocol",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/quinn-udp@0.5.14",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/quinn-rs/quinn"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#quinn@0.11.9",
+      "name": "quinn",
+      "version": "0.11.9",
+      "description": "Versatile QUIC transport protocol implementation",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/quinn@0.11.9",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/quinn-rs/quinn"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "quote",
+      "version": "1.0.45",
+      "description": "Quasi-quoting macro quote!(...)",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/quote@1.0.45",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/quote/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/quote"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+      "author": "The Rand Project Developers, The Rust Project Developers",
+      "name": "rand",
+      "version": "0.10.1",
+      "description": "Random number generators and other randomness functionality. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rand@0.10.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rand"
+        },
+        {
+          "type": "website",
+          "url": "https://rust-random.github.io/book"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/rand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rand@0.9.4",
+      "author": "The Rand Project Developers, The Rust Project Developers",
+      "name": "rand",
+      "version": "0.9.4",
+      "description": "Random number generators and other randomness functionality. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "44c5af06bb1b7d3216d91932aed5265164bf384dc89cd6ba05cf59a35f5f76ea"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rand@0.9.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rand"
+        },
+        {
+          "type": "website",
+          "url": "https://rust-random.github.io/book"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/rand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rand_chacha@0.9.0",
+      "author": "The Rand Project Developers, The Rust Project Developers, The CryptoCorrosion Contributors",
+      "name": "rand_chacha",
+      "version": "0.9.0",
+      "description": "ChaCha random number generator ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rand_chacha@0.9.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rand_chacha"
+        },
+        {
+          "type": "website",
+          "url": "https://rust-random.github.io/book"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/rand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.10.1",
+      "author": "The Rand Project Developers",
+      "name": "rand_core",
+      "version": "0.10.1",
+      "description": "Core random number generation traits and tools for implementation.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "63b8176103e19a2643978565ca18b50549f6101881c443590420e4dc998a3c69"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rand_core@0.10.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rand_core"
+        },
+        {
+          "type": "website",
+          "url": "https://rust-random.github.io/book"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/rand_core"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.9.5",
+      "author": "The Rand Project Developers, The Rust Project Developers",
+      "name": "rand_core",
+      "version": "0.9.5",
+      "description": "Core random number generator traits and tools for implementation. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rand_core@0.9.5",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rand_core"
+        },
+        {
+          "type": "website",
+          "url": "https://rust-random.github.io/book"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-random/rand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#redb@3.1.1",
+      "author": "Christopher Berner <me@cberner.com>",
+      "name": "redb",
+      "version": "3.1.1",
+      "description": "Rust Embedded DataBase",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ef99362319c782aa4639ad3a306b64c3bb90e12874e99b8df124cb679d988611"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/redb@3.1.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://www.redb.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/cberner/redb"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14",
+      "author": "The Rust Project Developers, Andrew Gallant <jamslam@gmail.com>",
+      "name": "regex-automata",
+      "version": "0.4.14",
+      "description": "Automata construction and matching using regular expressions.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/regex-automata@0.4.14",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/regex-automata"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/regex/tree/master/regex-automata"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/regex"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.10",
+      "author": "The Rust Project Developers, Andrew Gallant <jamslam@gmail.com>",
+      "name": "regex-syntax",
+      "version": "0.8.10",
+      "description": "A regular expression parser.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/regex-syntax@0.8.10",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/regex-syntax"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/regex/tree/master/regex-syntax"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/regex"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#regex@1.12.3",
+      "author": "The Rust Project Developers, Andrew Gallant <jamslam@gmail.com>",
+      "name": "regex",
+      "version": "1.12.3",
+      "description": "An implementation of regular expressions for Rust. This implementation uses finite automata and guarantees linear time matching on all inputs. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/regex@1.12.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/regex"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/regex"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/regex"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#reqwest-middleware@0.5.1",
+      "author": "Rodrigo Gryzinski <rodrigo.gryzinski@truelayer.com>",
+      "name": "reqwest-middleware",
+      "version": "0.5.1",
+      "description": "Wrapper around reqwest to allow for client middleware chains.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "199dda04a536b532d0cc04d7979e39b1c763ea749bf91507017069c00b96056f"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/reqwest-middleware@0.5.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/TrueLayer/reqwest-middleware"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#reqwest@0.13.2",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "reqwest",
+      "version": "0.13.2",
+      "description": "higher level HTTP client library",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ab3f43e3283ab1488b624b44b0e988d0acea0b3214e694730a055cb6b2efa801"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/reqwest@0.13.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/reqwest"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/seanmonstar/reqwest"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14",
+      "name": "ring",
+      "version": "0.17.14",
+      "description": "An experiment.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 AND ISC"
+        }
+      ],
+      "purl": "pkg:cargo/ring@0.17.14",
+      "externalReferences": [
+        {
+          "type": "other",
+          "url": "ring_core_0_17_14_"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/briansmith/ring"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustc-hash@2.1.1",
+      "author": "The Rust Project Developers",
+      "name": "rustc-hash",
+      "version": "2.1.1",
+      "description": "A speedy, non-cryptographic hashing algorithm used by rustc",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/rustc-hash@2.1.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/rustc-hash"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.4",
+      "author": "Dan Gohman <dev@sunfishcode.online>, Jakub Konka <kubkon@jakubkonka.com>",
+      "name": "rustix",
+      "version": "1.1.4",
+      "description": "Safe Rust bindings to POSIX/Unix/Linux/Winsock-like syscalls",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 WITH LLVM-exception OR Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/rustix@1.1.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rustix"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/bytecodealliance/rustix"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-native-certs@0.8.3",
+      "name": "rustls-native-certs",
+      "version": "0.8.3",
+      "description": "rustls-native-certs allows rustls to use the platform native certificate store",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "612460d5f7bea540c490b2b6395d8e34a953e52b491accd6c86c8164c5932a63"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR ISC OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/rustls-native-certs@0.8.3",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/rustls-native-certs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/rustls-native-certs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+      "name": "rustls-pki-types",
+      "version": "1.14.0",
+      "description": "Shared types for the rustls PKI ecosystem",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "be040f8b0a225e40375822a563fa9524378b9d63112f53e19ffff34df5d33fdd"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rustls-pki-types@1.14.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/rustls-pki-types"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/pki-types"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/pki-types"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-platform-verifier@0.6.2",
+      "name": "rustls-platform-verifier",
+      "version": "0.6.2",
+      "description": "rustls-platform-verifier supports verifying TLS certificates in rustls with the operating system verifier",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/rustls-platform-verifier@0.6.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/rustls-platform-verifier"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.15",
+      "name": "rustls-webpki",
+      "version": "0.103.15",
+      "description": "Web PKI X.509 Certificate Verification.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f3c3cf1d8b1e7d4927e2d154c3fcb02979afb9939629c62cd9048d4f07b60ac2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "ISC"
+        }
+      ],
+      "purl": "pkg:cargo/rustls-webpki@0.103.15",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/webpki"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+      "name": "rustls",
+      "version": "0.23.45",
+      "description": "Rustls is a modern TLS library written in Rust.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0d41d731c7d2f962d1ccc364cec258de3c0e93b38c2fb3ba97ac74513048d634"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR ISC OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/rustls@0.23.45",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/rustls"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/rustls"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#safe-transmute@0.11.3",
+      "author": "наб <nabijaczleweli@gmail.com>, Eduardo Pinho <enet4mikeenet@gmail.com>, Lukas Kalbertodt <lukas.kalbertodt@gmail.com>, Philipp Tessenow <philipp@tessenow.org>, Marijn Suijten <marijn@traverseresearch.nl>",
+      "name": "safe-transmute",
+      "version": "0.11.3",
+      "description": "A safeguarded transmute() for Rust",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3944826ff8fa8093089aba3acb4ef44b9446a99a16f3bf4e74af3f77d340ab7d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/safe-transmute@0.11.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://rawcdn.githack.com/nabijaczleweli/safe-transmute-rs/doc/safe_transmute/index.html"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/nabijaczleweli/safe-transmute-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+      "author": "Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>",
+      "name": "serde",
+      "version": "1.0.228",
+      "description": "A generic serialization/deserialization framework",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/serde@1.0.228",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/serde"
+        },
+        {
+          "type": "website",
+          "url": "https://serde.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/serde-rs/serde"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228",
+      "author": "Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>",
+      "name": "serde_core",
+      "version": "1.0.228",
+      "description": "Serde traits only, with no support for derive -- use the `serde` crate instead",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/serde_core@1.0.228",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/serde_core"
+        },
+        {
+          "type": "website",
+          "url": "https://serde.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/serde-rs/serde"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#serde_derive@1.0.228",
+      "author": "Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>",
+      "name": "serde_derive",
+      "version": "1.0.228",
+      "description": "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/serde_derive@1.0.228",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://serde.rs/derive.html"
+        },
+        {
+          "type": "website",
+          "url": "https://serde.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/serde-rs/serde"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+      "author": "Erick Tryzelaar <erick.tryzelaar@gmail.com>, David Tolnay <dtolnay@gmail.com>",
+      "name": "serde_json",
+      "version": "1.0.149",
+      "description": "A JSON serialization file format",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/serde_json@1.0.149",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/serde_json"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/serde-rs/json"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#serde_repr@0.1.20",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "serde_repr",
+      "version": "0.1.20",
+      "description": "Derive Serialize and Deserialize that delegates to the underlying repr of a C-like enum.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "175ee3e80ae9982737ca543e96133087cbd9a485eecc3bc4de9c1a37b47ea59c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/serde_repr@0.1.20",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/serde_repr"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/serde-repr"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#sha2@0.11.0",
+      "author": "RustCrypto Developers",
+      "name": "sha2",
+      "version": "0.11.0",
+      "description": "Pure Rust implementation of the SHA-2 hash function family including SHA-224, SHA-256, SHA-384, and SHA-512. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/sha2@0.11.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/sha2"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/hashes"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#sharded-slab@0.1.7",
+      "author": "Eliza Weisman <eliza@buoyant.io>",
+      "name": "sharded-slab",
+      "version": "0.1.7",
+      "description": "A lock-free concurrent slab. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/sharded-slab@0.1.7",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/sharded-slab/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/hawkw/sharded-slab"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hawkw/sharded-slab"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#shellexpand@3.1.2",
+      "author": "Vladimir Matveev <vmatveev@citrine.cc>, Ian Jackson <iwj@torproject.org>",
+      "name": "shellexpand",
+      "version": "3.1.2",
+      "description": "Shell-like expansions in strings",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "32824fab5e16e6c4d86dc1ba84489390419a39f97699852b66480bb87d297ed8"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/shellexpand@3.1.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "http://docs.rs/shellexpand/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://gitlab.com/ijackson/rust-shellexpand"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#shlex@1.3.0",
+      "author": "comex <comexk@gmail.com>, Fenhl <fenhl@fenhl.net>, Adrian Taylor <adetaylor@chromium.org>, Alex Touchet <alextouchet@outlook.com>, Daniel Parks <dp+git@oxidized.org>, Garrett Berg <googberg@gmail.com>",
+      "name": "shlex",
+      "version": "1.3.0",
+      "description": "Split a string into shell words, like Python's shlex.",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/shlex@1.3.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/comex/rust-shlex"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#signal-hook-registry@1.4.8",
+      "author": "Michal 'vorner' Vaner <vorner@vorner.cz>, Masaki Hara <ackie.h.gmai@gmail.com>",
+      "name": "signal-hook-registry",
+      "version": "1.4.8",
+      "description": "Backend crate for signal-hook",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/signal-hook-registry@1.4.8",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/signal-hook-registry"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/vorner/signal-hook"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#signal-hook@0.3.18",
+      "author": "Michal 'vorner' Vaner <vorner@vorner.cz>, Thomas Himmelstoss <thimm@posteo.de>",
+      "name": "signal-hook",
+      "version": "0.3.18",
+      "description": "Unix signal handling",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/signal-hook@0.3.18",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/signal-hook"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/vorner/signal-hook"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#slab@0.4.12",
+      "author": "Carl Lerche <me@carllerche.com>",
+      "name": "slab",
+      "version": "0.4.12",
+      "description": "Pre-allocated storage for a uniform data type",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/slab@0.4.12",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/slab"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1",
+      "author": "The Servo Project Developers",
+      "name": "smallvec",
+      "version": "1.15.1",
+      "description": "'Small vector' optimization: store up to a small number of items on the stack",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/smallvec@1.15.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/smallvec/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/servo/rust-smallvec"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+      "author": "Alex Crichton <alex@alexcrichton.com>, Thomas de Zeeuw <thomasdezeeuw@gmail.com>",
+      "name": "socket2",
+      "version": "0.6.3",
+      "description": "Utilities for handling networking sockets with a maximal amount of configuration possible intended. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/socket2@0.6.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/socket2"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rust-lang/socket2"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rust-lang/socket2"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#stable_deref_trait@1.2.1",
+      "author": "Robert Grosse <n210241048576@gmail.com>",
+      "name": "stable_deref_trait",
+      "version": "1.2.1",
+      "description": "An unsafe marker trait for types like Box and Rc that dereference to a stable address even when moved, and hence can be used with libraries such as owning_ref and rental. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/stable_deref_trait@1.2.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/stable_deref_trait/1.2.1/stable_deref_trait"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/storyyeller/stable_deref_trait"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#static_assertions@1.1.0",
+      "author": "Nikolai Vazquez",
+      "name": "static_assertions",
+      "version": "1.1.0",
+      "description": "Compile-time assertions to ensure that invariants are met.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/static_assertions@1.1.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/static_assertions/"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/nvzqz/static-assertions-rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/nvzqz/static-assertions-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#statrs@0.18.0",
+      "author": "Michael Ma",
+      "name": "statrs",
+      "version": "0.18.0",
+      "description": "Statistical computing library for Rust",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2a3fe7c28c6512e766b0874335db33c94ad7b8f9054228ae1c2abd47ce7d335e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/statrs@0.18.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/statrs-dev/statrs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/statrs-dev/statrs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#subtle@2.6.1",
+      "author": "Isis Lovecruft <isis@patternsinthevoid.net>, Henry de Valence <hdevalence@hdevalence.ca>",
+      "name": "subtle",
+      "version": "2.6.1",
+      "description": "Pure-Rust traits and utilities for constant-time cryptographic implementations.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "BSD-3-Clause"
+        }
+      ],
+      "purl": "pkg:cargo/subtle@2.6.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/subtle"
+        },
+        {
+          "type": "website",
+          "url": "https://dalek.rs/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dalek-cryptography/subtle"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "syn",
+      "version": "2.0.117",
+      "description": "Parser for Rust source code",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/syn@2.0.117",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/syn"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/syn"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@1.0.2",
+      "author": "Actyx AG <developer@actyx.io>",
+      "name": "sync_wrapper",
+      "version": "1.0.2",
+      "description": "A tool for enlisting the compiler's help in proving the absence of concurrency",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/sync_wrapper@1.0.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/sync_wrapper"
+        },
+        {
+          "type": "website",
+          "url": "https://docs.rs/sync_wrapper"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/Actyx/sync_wrapper"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#synstructure@0.13.2",
+      "author": "Nika Layzell <nika@thelayzells.com>",
+      "name": "synstructure",
+      "version": "0.13.2",
+      "description": "Helper methods and macros for custom derives",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/synstructure@0.13.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/synstructure"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/mystor/synstructure"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#sysinfo@0.39.6",
+      "author": "Guillaume Gomez <guillaume1.gomez@gmail.com>",
+      "name": "sysinfo",
+      "version": "0.39.6",
+      "description": "Library to get system information such as processes, CPUs, disks, components and networks",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d2071df9448915b71c4fe6d25deaf1c22f12bd234f01540b77312bb8e41361e6"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/sysinfo@0.39.6",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/GuillaumeGomez/sysinfo"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#target-lexicon@0.13.5",
+      "author": "Dan Gohman <sunfish@mozilla.com>",
+      "name": "target-lexicon",
+      "version": "0.13.5",
+      "description": "LLVM target triple types",
+      "scope": "excluded",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 WITH LLVM-exception"
+        }
+      ],
+      "purl": "pkg:cargo/target-lexicon@0.13.5",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/target-lexicon/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/bytecodealliance/target-lexicon"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tempfile@3.27.0",
+      "author": "Steven Allen <steven@stebalien.com>, The Rust Project Developers, Ashley Mannix <ashleymannix@live.com.au>, Jason White <me@jasonwhite.io>",
+      "name": "tempfile",
+      "version": "3.27.0",
+      "description": "A library for managing temporary files and directories.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/tempfile@3.27.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/tempfile"
+        },
+        {
+          "type": "website",
+          "url": "https://stebalien.com/projects/tempfile-rs/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/Stebalien/tempfile"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#thiserror-impl@2.0.18",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "thiserror-impl",
+      "version": "2.0.18",
+      "description": "Implementation detail of the `thiserror` crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/thiserror-impl@2.0.18",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/thiserror"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "thiserror",
+      "version": "2.0.18",
+      "description": "derive(Error)",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/thiserror@2.0.18",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/thiserror"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/thiserror"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#thread_local@1.1.9",
+      "author": "Amanieu d'Antras <amanieu@gmail.com>",
+      "name": "thread_local",
+      "version": "1.1.9",
+      "description": "Per-object thread-local storage",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/thread_local@1.1.9",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/thread_local/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/Amanieu/thread_local-rs"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#time-core@0.1.8",
+      "author": "Jacob Pratt <open-source@jhpratt.dev>, Time contributors",
+      "name": "time-core",
+      "version": "0.1.8",
+      "description": "This crate is an implementation detail and should not be relied upon directly.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/time-core@0.1.8",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/time-rs/time"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#time-macros@0.2.27",
+      "author": "Jacob Pratt <open-source@jhpratt.dev>, Time contributors",
+      "name": "time-macros",
+      "version": "0.2.27",
+      "description": "    Procedural macros for the time crate.     This crate is an implementation detail and should not be relied upon directly. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/time-macros@0.2.27",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/time-rs/time"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#time@0.3.47",
+      "author": "Jacob Pratt <open-source@jhpratt.dev>, Time contributors",
+      "name": "time",
+      "version": "0.3.47",
+      "description": "Date and time library. Fully interoperable with the standard library. Mostly compatible with #![no_std].",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/time@0.3.47",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://time-rs.github.io"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/time-rs/time"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tinystr@0.8.2",
+      "author": "The ICU4X Project Developers",
+      "name": "tinystr",
+      "version": "0.8.2",
+      "description": "A small ASCII-only bounded length string representation.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/tinystr@0.8.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tinyvec@1.11.0",
+      "author": "Lokathor <zefria@gmail.com>",
+      "name": "tinyvec",
+      "version": "1.11.0",
+      "description": "`tinyvec` provides 100% safe vec-like data structures.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "3e61e67053d25a4e82c844e8424039d9745781b3fc4f32b8d55ed50f5f667ef3"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib OR Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tinyvec@1.11.0",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/Lokathor/tinyvec"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tinyvec_macros@0.1.1",
+      "author": "Soveu <marx.tomasz@gmail.com>",
+      "name": "tinyvec_macros",
+      "version": "0.1.1",
+      "description": "Some macros for tiny containers",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0 OR Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/tinyvec_macros@0.1.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/Soveu/tinyvec_macros"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-macros@2.6.1",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tokio-macros",
+      "version": "2.6.1",
+      "description": "Tokio's proc macros. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "5c55a2eff8b69ce66c84f85e1da1c233edc36ceb85a2058d11b0d6a3c7e7569c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tokio-macros@2.6.1",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tokio"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-retry@0.3.1",
+      "name": "tokio-retry",
+      "version": "0.3.1",
+      "description": "Extensible, asynchronous retry behaviours for futures/tokio",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "40f644c762e9d396831ae2f8935c954b0d758c4532e924bead0f666d0c1c8640"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tokio-retry@0.3.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/tokio-retry"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/djc/tokio-retry"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-rustls@0.26.4",
+      "name": "tokio-rustls",
+      "version": "0.26.4",
+      "description": "Asynchronous TLS/SSL streams for Tokio using Rustls.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/tokio-rustls@0.26.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/tokio-rustls"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/rustls/tokio-rustls"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rustls/tokio-rustls"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tokio-util",
+      "version": "0.7.18",
+      "description": "Additional utilities for working with Tokio. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tokio-util@0.7.18",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tokio"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tokio",
+      "version": "1.50.0",
+      "description": "An event-driven, non-blocking I/O platform for writing asynchronous I/O backed applications. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tokio@1.50.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tokio"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tower-http@0.6.8",
+      "author": "Tower Maintainers <team@tower-rs.com>",
+      "name": "tower-http",
+      "version": "0.6.8",
+      "description": "Tower middleware and utilities for HTTP clients and servers",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d4e6559d53cc268e5031cd8429d05415bc4cb4aefc4aa5d6cc35fbf5b924a1f8"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tower-http@0.6.8",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/tower-rs/tower-http"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tower-rs/tower-http"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tower-layer@0.3.3",
+      "author": "Tower Maintainers <team@tower-rs.com>",
+      "name": "tower-layer",
+      "version": "0.3.3",
+      "description": "Decorates a `Service` to allow easy composition between `Service`s. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tower-layer@0.3.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/tower-layer/0.3.3"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/tower-rs/tower"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tower-rs/tower"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3",
+      "author": "Tower Maintainers <team@tower-rs.com>",
+      "name": "tower-service",
+      "version": "0.3.3",
+      "description": "Trait representing an asynchronous, request / response based, client or server. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tower-service@0.3.3",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/tower-service/0.3.3"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/tower-rs/tower"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tower-rs/tower"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tower@0.5.3",
+      "author": "Tower Maintainers <team@tower-rs.com>",
+      "name": "tower",
+      "version": "0.5.3",
+      "description": "Tower is a library of modular and reusable components for building robust clients and servers. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ebe5ef63511595f1344e2d5cfa636d973292adc0eec1f0ad45fae9f0851ab1d4"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tower@0.5.3",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/tower-rs/tower"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tower-rs/tower"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-appender@0.2.4",
+      "author": "Zeki Sherif <zekshi@amazon.com>, Tokio Contributors <team@tokio.rs>",
+      "name": "tracing-appender",
+      "version": "0.2.4",
+      "description": "Provides utilities for file appenders and making non-blocking writers. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "786d480bce6247ab75f005b14ae1624ad978d3029d9113f0a22fa1ac773faeaf"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-appender@0.2.4",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-attributes@0.1.31",
+      "author": "Tokio Contributors <team@tokio.rs>, Eliza Weisman <eliza@buoyant.io>, David Barsky <dbarsky@amazon.com>",
+      "name": "tracing-attributes",
+      "version": "0.1.31",
+      "description": "Procedural macro attributes for automatically instrumenting functions. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-attributes@0.1.31",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tracing-core",
+      "version": "0.1.36",
+      "description": "Core primitives for application-level tracing. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "db97caf9d906fbde555dd62fa95ddba9eecfd14cb388e4f491a66d74cd5fb79a"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-core@0.1.36",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-log@0.2.0",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tracing-log",
+      "version": "0.2.0",
+      "description": "Provides compatibility between `tracing` and the `log` crate. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-log@0.2.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-serde@0.2.0",
+      "author": "Tokio Contributors <team@tokio.rs>",
+      "name": "tracing-serde",
+      "version": "0.2.0",
+      "description": "A compatibility layer for serializing trace data with `serde` ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "704b1aeb7be0d0a84fc9828cae51dab5970fee5088f83d1dd7ee6f6246fc6ff1"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-serde@0.2.0",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-subscriber@0.3.23",
+      "author": "Eliza Weisman <eliza@buoyant.io>, David Barsky <me@davidbarsky.com>, Tokio Contributors <team@tokio.rs>",
+      "name": "tracing-subscriber",
+      "version": "0.3.23",
+      "description": "Utilities for implementing and composing `tracing` subscribers. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "cb7f578e5945fb242538965c2d0b04418d38ec25c79d160cd279bf0731c8d319"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing-subscriber@0.3.23",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+      "author": "Eliza Weisman <eliza@buoyant.io>, Tokio Contributors <team@tokio.rs>",
+      "name": "tracing",
+      "version": "0.1.44",
+      "description": "Application-level tracing for Rust. ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "63e71662fa4b2a2c3a26f570f037eb95bb1f85397f3cd8076caed2f026a6d100"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/tracing@0.1.44",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://tokio.rs"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/tokio-rs/tracing"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#try-lock@0.2.5",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "try-lock",
+      "version": "0.2.5",
+      "description": "A lightweight atomic lock.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/try-lock@0.2.5",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/try-lock"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/seanmonstar/try-lock"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/seanmonstar/try-lock"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#twox-hash@2.1.2",
+      "author": "Jake Goulding <jake.goulding@gmail.com>",
+      "name": "twox-hash",
+      "version": "2.1.2",
+      "description": "A Rust implementation of the XXHash and XXH3 algorithms",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/twox-hash@2.1.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/twox-hash/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/shepmaster/twox-hash"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#typenum@1.20.1",
+      "name": "typenum",
+      "version": "1.20.1",
+      "description": "Typenum is a Rust library for type-level numbers evaluated at     compile time. It currently supports bits, unsigned integers, and signed     integers. It also provides a type-level array of type-level numbers, but its     implementation is incomplete.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/typenum@1.20.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/typenum"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/paholg/typenum"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#typewit@1.14.2",
+      "author": "rodrimati1992 <rodrimatt1985@gmail.com>",
+      "name": "typewit",
+      "version": "1.14.2",
+      "description": "type-witness-based abstractions, mostly for emulating polymorphism in const fns",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Zlib"
+        }
+      ],
+      "purl": "pkg:cargo/typewit@1.14.2",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/typewit/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/rodrimati1992/typewit/"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#unicode-ident@1.0.24",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "unicode-ident",
+      "version": "1.0.24",
+      "description": "Determine whether characters have the XID_Start or XID_Continue properties according to Unicode Standard Annex #31",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "(MIT OR Apache-2.0) AND Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/unicode-ident@1.0.24",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/unicode-ident"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/unicode-ident"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0",
+      "author": "Brian Smith <brian@briansmith.org>",
+      "name": "untrusted",
+      "version": "0.9.0",
+      "description": "Safe, fast, zero-panic, zero-crashing, zero-allocation parsing of untrusted inputs in Rust.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "ISC"
+        }
+      ],
+      "purl": "pkg:cargo/untrusted@0.9.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://briansmith.org/rustdoc/untrusted/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/briansmith/untrusted"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#url@2.5.8",
+      "author": "The rust-url developers",
+      "name": "url",
+      "version": "2.5.8",
+      "description": "URL library for Rust, based on the WHATWG URL Standard",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT OR Apache-2.0"
+        }
+      ],
+      "purl": "pkg:cargo/url@2.5.8",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/url"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/servo/rust-url"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#urlencoding@2.1.3",
+      "author": "Kornel <kornel@geekhood.net>, Bertram Truong <b@bertramtruong.com>",
+      "name": "urlencoding",
+      "version": "2.1.3",
+      "description": "A Rust library for doing URL percentage encoding.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/urlencoding@2.1.3",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://lib.rs/urlencoding"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/kornelski/rust_urlencoding"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#utf8_iter@1.0.4",
+      "author": "Henri Sivonen <hsivonen@hsivonen.fi>",
+      "name": "utf8_iter",
+      "version": "1.0.4",
+      "description": "Iterator by char over potentially-invalid UTF-8 in &[u8]",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/utf8_iter@1.0.4",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/utf8_iter/"
+        },
+        {
+          "type": "website",
+          "url": "https://docs.rs/utf8_iter/"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/hsivonen/utf8_iter"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+      "author": "Ashley Mannix<ashleymannix@live.com.au>, Dylan DPC<dylan.dpc@gmail.com>, Hunar Roop Kahlon<hunar.roop@gmail.com>",
+      "name": "uuid",
+      "version": "1.22.0",
+      "description": "A library to generate and parse UUIDs.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/uuid@1.22.0",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/uuid"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/uuid-rs/uuid"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/uuid-rs/uuid"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#want@0.3.1",
+      "author": "Sean McArthur <sean@seanmonstar.com>",
+      "name": "want",
+      "version": "0.3.1",
+      "description": "Detect when another Future wants a result.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/want@0.3.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/want"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/seanmonstar/want"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#whoami@2.1.1",
+      "name": "whoami",
+      "version": "2.1.1",
+      "description": "Rust library for getting information about the current user and environment",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d6a5b12f9df4f978d2cfdb1bd3bac52433f44393342d7ee9c25f5a1c14c0f45d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR BSL-1.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/whoami@2.1.1",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/whoami"
+        },
+        {
+          "type": "website",
+          "url": "https://github.com/ardaku/whoami/releases"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/ardaku/whoami"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.2",
+      "author": "The ICU4X Project Developers",
+      "name": "writeable",
+      "version": "0.6.2",
+      "description": "A more efficient alternative to fmt::Display",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/writeable@0.6.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#yoke-derive@0.8.1",
+      "author": "Manish Goregaokar <manishsmail@gmail.com>",
+      "name": "yoke-derive",
+      "version": "0.8.1",
+      "description": "Custom derive for the yoke crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/yoke-derive@0.8.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+      "author": "Manish Goregaokar <manishsmail@gmail.com>",
+      "name": "yoke",
+      "version": "0.8.1",
+      "description": "Abstraction allowing borrowed data to be carried along with the backing data it borrows from",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/yoke@0.8.1",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.47",
+      "author": "Joshua Liebow-Feeser <joshlf@google.com>, Jack Wrenn <jswrenn@amazon.com>",
+      "name": "zerocopy",
+      "version": "0.8.47",
+      "description": "Zerocopy makes zero-cost memory manipulation effortless. We write \"unsafe\" so you don't have to.",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "efbb2a062be311f2ba113ce66f697a4dc589f85e78a4aea276200804cea0ed87"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "BSD-2-Clause OR Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/zerocopy@0.8.47",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/google/zerocopy"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerofrom-derive@0.1.6",
+      "author": "Manish Goregaokar <manishsmail@gmail.com>",
+      "name": "zerofrom-derive",
+      "version": "0.1.6",
+      "description": "Custom derive for the zerofrom crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/zerofrom-derive@0.1.6",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6",
+      "author": "Manish Goregaokar <manishsmail@gmail.com>",
+      "name": "zerofrom",
+      "version": "0.1.6",
+      "description": "ZeroFrom trait for constructing",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/zerofrom@0.1.6",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2",
+      "author": "The RustCrypto Project Developers",
+      "name": "zeroize",
+      "version": "1.8.2",
+      "description": "Securely clear secrets from memory with a simple trait built on stable Rust primitives which guarantee memory is zeroed using an operation will not be 'optimized away' by the compiler. Uses a portable pure Rust implementation that works everywhere, even WASM! ",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Apache-2.0 OR MIT"
+        }
+      ],
+      "purl": "pkg:cargo/zeroize@1.8.2",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://github.com/RustCrypto/utils/tree/master/zeroize"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/RustCrypto/utils"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.3",
+      "author": "The ICU4X Project Developers",
+      "name": "zerotrie",
+      "version": "0.2.3",
+      "description": "A data structure that efficiently maps strings to integers",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/zerotrie@0.2.3",
+      "externalReferences": [
+        {
+          "type": "website",
+          "url": "https://icu4x.unicode.org"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerovec-derive@0.11.2",
+      "author": "Manish Goregaokar <manishsmail@gmail.com>",
+      "name": "zerovec-derive",
+      "version": "0.11.2",
+      "description": "Custom derive for the zerovec crate",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/zerovec-derive@0.11.2",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5",
+      "author": "The ICU4X Project Developers",
+      "name": "zerovec",
+      "version": "0.11.5",
+      "description": "Zero-copy vector backed by a byte array",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "Unicode-3.0"
+        }
+      ],
+      "purl": "pkg:cargo/zerovec@0.11.5",
+      "externalReferences": [
+        {
+          "type": "vcs",
+          "url": "https://github.com/unicode-org/icu4x"
+        }
+      ]
+    },
+    {
+      "type": "library",
+      "bom-ref": "registry+https://github.com/rust-lang/crates.io-index#zmij@1.0.21",
+      "author": "David Tolnay <dtolnay@gmail.com>",
+      "name": "zmij",
+      "version": "1.0.21",
+      "description": "A double-to-string conversion algorithm based on Schubfach and yy",
+      "scope": "required",
+      "hashes": [
+        {
+          "alg": "SHA-256",
+          "content": "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
+        }
+      ],
+      "licenses": [
+        {
+          "expression": "MIT"
+        }
+      ],
+      "purl": "pkg:cargo/zmij@1.0.21",
+      "externalReferences": [
+        {
+          "type": "documentation",
+          "url": "https://docs.rs/zmij"
+        },
+        {
+          "type": "vcs",
+          "url": "https://github.com/dtolnay/zmij"
+        }
+      ]
+    }
+  ],
+  "dependencies": [
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/hf_xet#1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_pkg#hf-xet@1.7.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#signal-hook@0.3.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_client#xet-client@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0"
+      ]
+    },
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/xet_client#xet-client@1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.44",
+        "registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0",
+        "registry+https://github.com/rust-lang/crates.io-index#futures@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#redb@3.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#reqwest@0.13.2",
+        "registry+https://github.com/rust-lang/crates.io-index#reqwest-middleware@0.5.1",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_repr@0.1.20",
+        "registry+https://github.com/rust-lang/crates.io-index#statrs@0.18.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tempfile@3.27.0",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-retry@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#url@2.5.8",
+        "registry+https://github.com/rust-lang/crates.io-index#urlencoding@2.1.3",
+        "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_core_structures#xet-core-structures@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0"
+      ]
+    },
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/xet_core_structures#xet-core-structures@1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1",
+        "registry+https://github.com/rust-lang/crates.io-index#blake3@1.8.3",
+        "registry+https://github.com/rust-lang/crates.io-index#bytemuck@1.25.0",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#countio@0.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#futures@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#heapify@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#lz4_flex@0.13.0",
+        "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#regex@1.12.3",
+        "registry+https://github.com/rust-lang/crates.io-index#safe-transmute@0.11.3",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#static_assertions@1.1.0",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0"
+      ]
+    },
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/xet_data#xet-data@1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.44",
+        "registry+https://github.com/rust-lang/crates.io-index#gearhash@0.1.3",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#sha2@0.11.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tempfile@3.27.0",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#url@2.5.8",
+        "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_client#xet-client@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_core_structures#xet-core-structures@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0"
+      ]
+    },
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/xet_pkg#hf-xet@1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_client#xet-client@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_core_structures#xet-core-structures@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_data#xet-data@1.7.0",
+        "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0"
+      ]
+    },
+    {
+      "ref": "path+file:///home/runner/work/xet-core/xet-core/xet_runtime#xet-runtime@1.7.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.44",
+        "registry+https://github.com/rust-lang/crates.io-index#colored@3.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#const-str@1.1.0",
+        "registry+https://github.com/rust-lang/crates.io-index#ctor@1.0.3",
+        "registry+https://github.com/rust-lang/crates.io-index#dirs@6.0.0",
+        "registry+https://github.com/rust-lang/crates.io-index#futures@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#git-version@0.3.9",
+        "registry+https://github.com/rust-lang/crates.io-index#humantime@2.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#konst@0.4.3",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1",
+        "registry+https://github.com/rust-lang/crates.io-index#oneshot@0.1.13",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project@1.1.11",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#reqwest@0.13.2",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#shellexpand@3.1.2",
+        "registry+https://github.com/rust-lang/crates.io-index#sysinfo@0.39.6",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-appender@0.2.4",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-subscriber@0.3.23",
+        "registry+https://github.com/rust-lang/crates.io-index#whoami@2.1.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#approx@0.5.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#arrayref@0.3.9"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#arrayvec@0.7.6"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#atomic-waker@1.1.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#autocfg@1.5.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#aws-lc-rs@1.18.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aws-lc-sys@0.45.0",
+        "registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#aws-lc-sys@0.45.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57",
+        "registry+https://github.com/rust-lang/crates.io-index#cmake@0.1.57",
+        "registry+https://github.com/rust-lang/crates.io-index#dunce@1.0.5",
+        "registry+https://github.com/rust-lang/crates.io-index#fs_extra@1.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#pkg-config@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#bitflags@2.11.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#blake3@1.8.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#arrayref@0.3.9",
+        "registry+https://github.com/rust-lang/crates.io-index#arrayvec@0.7.6",
+        "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57",
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#constant_time_eq@0.4.2",
+        "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.2.17"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#block-buffer@0.12.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#hybrid-array@0.4.13"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#bstr@1.12.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#bytemuck@1.25.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#find-msvc-tools@0.1.9",
+        "registry+https://github.com/rust-lang/crates.io-index#jobserver@0.1.34",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#shlex@1.3.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cfg-if@0.1.10"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cfg_aliases@0.2.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#chacha20@0.10.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.10.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.44",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#iana-time-zone@0.1.65",
+        "registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cmake@0.1.57",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#colored@3.1.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#const-oid@0.10.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#const-str@1.1.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#const_panic@0.2.15",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#typewit@1.14.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#constant_time_eq@0.4.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#countio@0.3.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.2.17"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.3.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#crossbeam-channel@0.5.15",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#crypto-common@0.2.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#hybrid-array@0.4.13"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#ctor@1.0.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#link-section@0.15.0",
+        "registry+https://github.com/rust-lang/crates.io-index#linktime-proc-macro@0.1.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#deranged@0.5.8",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#powerfmt@0.2.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#digest@0.11.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#block-buffer@0.12.1",
+        "registry+https://github.com/rust-lang/crates.io-index#const-oid@0.10.2",
+        "registry+https://github.com/rust-lang/crates.io-index#crypto-common@0.2.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#dirs-sys@0.5.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#option-ext@0.2.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#dirs@6.0.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#dirs-sys@0.5.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#dunce@1.0.5"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#either@1.15.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#errno@0.3.14",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#fastrand@2.3.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#find-msvc-tools@0.1.9"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#form_urlencoded@1.2.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#fs_extra@1.3.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-executor@0.3.32",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.32"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-macro@0.3.32",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.32"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-macro@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#slab@0.4.12"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#futures@0.3.32",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-executor@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#gearhash@0.1.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@0.1.10"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.2.17",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.4.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.10.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#git-version-macro@0.3.9",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#git-version@0.3.9",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#git-version-macro@0.3.9"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#heapify@0.2.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#heck@0.5.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#http-body-util@0.1.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#humantime@2.3.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#hybrid-array@0.4.13",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#typenum@1.20.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#hyper-rustls@0.27.7",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper-util@0.1.20",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-rustls@0.26.4",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#hyper-util@0.1.20",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#ipnet@2.12.0",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#atomic-waker@1.1.2",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+        "registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-utils@0.1.0",
+        "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#want@0.3.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#iana-time-zone@0.1.65"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+        "registry+https://github.com/rust-lang/crates.io-index#potential_utf@0.1.4",
+        "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+        "registry+https://github.com/rust-lang/crates.io-index#litemap@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#tinystr@0.8.2",
+        "registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.2",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer@2.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.1.2",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.1.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.1.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.1.2",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.3",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.1.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.2",
+        "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6",
+        "registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.3",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#idna@1.1.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#idna_adapter@1.2.1",
+        "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1",
+        "registry+https://github.com/rust-lang/crates.io-index#utf8_iter@1.0.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#idna_adapter@1.2.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#icu_normalizer@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.1.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#inventory@0.3.22"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#ipnet@2.12.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#iri-string@0.7.11",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#either@1.15.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#jobserver@0.1.34",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#konst@0.4.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#const_panic@0.2.15",
+        "registry+https://github.com/rust-lang/crates.io-index#konst_proc_macros@0.4.1",
+        "registry+https://github.com/rust-lang/crates.io-index#typewit@1.14.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#konst_proc_macros@0.4.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#lazy_static@1.5.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#link-section@0.15.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#linktime-proc-macro@0.1.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#linux-raw-sys@0.12.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#litemap@0.8.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#log@0.4.29"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#lru-slab@0.1.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#lz4_flex@0.13.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#twox-hash@2.1.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#matchers@0.2.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#mio@1.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#more-asserts@0.3.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#nu-ansi-term@0.50.3"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#num-conv@0.2.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#autocfg@1.5.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#oneshot@0.1.13"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#openssl-probe@0.2.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#option-ext@0.2.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#os_str_bytes@6.6.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project-internal@1.1.11",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pin-project@1.1.11",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-internal@1.1.11"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pin-utils@0.1.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pkg-config@0.3.32"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#potential_utf@0.1.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#powerfmt@0.2.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#ppv-lite86@0.2.21",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.47"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#unicode-ident@1.0.24"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-build-config@0.29.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#target-lexicon@0.13.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-ffi@0.29.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3-build-config@0.29.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros-backend@0.29.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#heck@0.5.0",
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros@0.29.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros-backend@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#pyo3@0.29.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#inventory@0.3.22",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3-build-config@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3-ffi@0.29.0",
+        "registry+https://github.com/rust-lang/crates.io-index#pyo3-macros@0.29.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#quinn-proto@0.11.15",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aws-lc-rs@1.18.1",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#lru-slab@0.1.2",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.9.4",
+        "registry+https://github.com/rust-lang/crates.io-index#rustc-hash@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#slab@0.4.12",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tinyvec@1.11.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#quinn-udp@0.5.14",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg_aliases@0.2.1",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#quinn@0.11.9",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#cfg_aliases@0.2.1",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#quinn-proto@0.11.15",
+        "registry+https://github.com/rust-lang/crates.io-index#quinn-udp@0.5.14",
+        "registry+https://github.com/rust-lang/crates.io-index#rustc-hash@2.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#chacha20@0.10.2",
+        "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.4.2",
+        "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.10.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rand@0.9.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#rand_chacha@0.9.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.9.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rand_chacha@0.9.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#ppv-lite86@0.2.21",
+        "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.9.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.10.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rand_core@0.9.5",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#redb@3.1.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.4",
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.10"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.10"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#regex@1.12.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.4",
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14",
+        "registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.10"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#reqwest-middleware@0.5.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.103",
+        "registry+https://github.com/rust-lang/crates.io-index#async-trait@0.1.89",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#reqwest@0.13.2",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#reqwest@0.13.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body-util@0.1.3",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper@1.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper-rustls@0.27.7",
+        "registry+https://github.com/rust-lang/crates.io-index#hyper-util@0.1.20",
+        "registry+https://github.com/rust-lang/crates.io-index#log@0.4.29",
+        "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#quinn@0.11.9",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-platform-verifier@0.6.2",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@1.0.2",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-rustls@0.26.4",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+        "registry+https://github.com/rust-lang/crates.io-index#tower@0.5.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-http@0.6.8",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3",
+        "registry+https://github.com/rust-lang/crates.io-index#url@2.5.8"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cc@1.2.57",
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustc-hash@2.1.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bitflags@2.11.0",
+        "registry+https://github.com/rust-lang/crates.io-index#errno@0.3.14",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#linux-raw-sys@0.12.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-native-certs@0.8.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#openssl-probe@0.2.1",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-platform-verifier@0.6.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#log@0.4.29",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-native-certs@0.8.3",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.15"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.15",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aws-lc-rs@1.18.1",
+        "registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#aws-lc-rs@1.18.1",
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.14.0",
+        "registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.15",
+        "registry+https://github.com/rust-lang/crates.io-index#subtle@2.6.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#safe-transmute@0.11.3"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_derive@1.0.228"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#serde_derive@1.0.228",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#zmij@1.0.21"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#serde_repr@0.1.20",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#sha2@0.11.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4",
+        "registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#digest@0.11.3"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#sharded-slab@0.1.7",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#lazy_static@1.5.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#shellexpand@3.1.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bstr@1.12.1",
+        "registry+https://github.com/rust-lang/crates.io-index#dirs@6.0.0",
+        "registry+https://github.com/rust-lang/crates.io-index#os_str_bytes@6.6.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#shlex@1.3.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#signal-hook-registry@1.4.8",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#errno@0.3.14",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#signal-hook@0.3.18",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#signal-hook-registry@1.4.8"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#slab@0.4.12"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#stable_deref_trait@1.2.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#static_assertions@1.1.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#statrs@0.18.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#approx@0.5.1",
+        "registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#subtle@2.6.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#unicode-ident@1.0.24"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@1.0.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#synstructure@0.13.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#sysinfo@0.39.6",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#memchr@2.8.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#target-lexicon@0.13.5"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tempfile@3.27.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#fastrand@2.3.0",
+        "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.4.2",
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+        "registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#thiserror-impl@2.0.18",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror-impl@2.0.18"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#thread_local@1.1.9",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#time-core@0.1.8"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#time-macros@0.2.27",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#num-conv@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#time-core@0.1.8"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#time@0.3.47",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#deranged@0.5.8",
+        "registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#num-conv@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#powerfmt@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#time-core@0.1.8",
+        "registry+https://github.com/rust-lang/crates.io-index#time-macros@0.2.27"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tinystr@0.8.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tinyvec@1.11.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#tinyvec_macros@0.1.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tinyvec_macros@0.1.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-macros@2.6.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-retry@0.3.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#rand@0.10.1",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-rustls@0.26.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.45",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.18",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183",
+        "registry+https://github.com/rust-lang/crates.io-index#mio@1.1.1",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio-macros@2.6.1"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tower-http@0.6.8",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#bitflags@2.11.0",
+        "registry+https://github.com/rust-lang/crates.io-index#bytes@1.11.1",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#http@1.4.0",
+        "registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1",
+        "registry+https://github.com/rust-lang/crates.io-index#iri-string@0.7.11",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#tower@0.5.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-layer@0.3.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tower-layer@0.3.3"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tower@0.5.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.32",
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@1.0.2",
+        "registry+https://github.com/rust-lang/crates.io-index#tokio@1.50.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-layer@0.3.3",
+        "registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-appender@0.2.4",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#crossbeam-channel@0.5.15",
+        "registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.18",
+        "registry+https://github.com/rust-lang/crates.io-index#time@0.3.47",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-subscriber@0.3.23"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-attributes@0.1.31",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-log@0.2.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#log@0.4.29",
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-serde@0.2.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing-subscriber@0.3.23",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#matchers@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#nu-ansi-term@0.50.3",
+        "registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.4",
+        "registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.14",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228",
+        "registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.149",
+        "registry+https://github.com/rust-lang/crates.io-index#sharded-slab@0.1.7",
+        "registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1",
+        "registry+https://github.com/rust-lang/crates.io-index#thread_local@1.1.9",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-log@0.2.0",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-serde@0.2.0"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.44",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.17",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-attributes@0.1.31",
+        "registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.36"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#try-lock@0.2.5"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#twox-hash@2.1.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#typenum@1.20.1"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#typewit@1.14.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#unicode-ident@1.0.24"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#url@2.5.8",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#form_urlencoded@1.2.2",
+        "registry+https://github.com/rust-lang/crates.io-index#idna@1.1.0",
+        "registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2",
+        "registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#urlencoding@2.1.3"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#utf8_iter@1.0.4"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#uuid@1.22.0",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#getrandom@0.4.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#want@0.3.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#try-lock@0.2.5"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#whoami@2.1.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#libc@0.2.183"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#yoke-derive@0.8.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117",
+        "registry+https://github.com/rust-lang/crates.io-index#synstructure@0.13.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#stable_deref_trait@1.2.1",
+        "registry+https://github.com/rust-lang/crates.io-index#yoke-derive@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.47"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerofrom-derive@0.1.6",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117",
+        "registry+https://github.com/rust-lang/crates.io-index#synstructure@0.13.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom-derive@0.1.6"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2"
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.3",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5",
+        "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerovec-derive@0.11.2",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.106",
+        "registry+https://github.com/rust-lang/crates.io-index#quote@1.0.45",
+        "registry+https://github.com/rust-lang/crates.io-index#syn@2.0.117"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.5",
+      "dependsOn": [
+        "registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.1",
+        "registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6",
+        "registry+https://github.com/rust-lang/crates.io-index#zerovec-derive@0.11.2"
+      ]
+    },
+    {
+      "ref": "registry+https://github.com/rust-lang/crates.io-index#zmij@1.0.21"
+    }
+  ]
+}
\ No newline at end of file
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..96ed54a8a066d681e4973e5841a0f5577b619698
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/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__
\ No newline at end of file
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03c5d673ddf06b65d7420eab2f657f3c687acf19
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/hf_xet.abi3.so b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/hf_xet/hf_xet.abi3.so
new file mode 100644
index 0000000000000000000000000000000000000000..83114cec8ea1dcbf4ce7ba43fc37cc9dbcf7f15c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/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:a4e40058860f3ad4ca9b0193d47b47e0e7bf8ca7e5ae0735696274c6c4c1706b
+size 11274016
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..8594aca521dc8f5852919e32d37b1d4185adb453
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/METADATA
@@ -0,0 +1,781 @@
+Metadata-Version: 2.5
+Name: httpcore2
+Version: 2.15.1
+Summary: A minimal low-level HTTP client.
+Project-URL: Changelog, https://github.com/pydantic/httpx2/blob/main/src/httpcore2/CHANGELOG.md
+Project-URL: Homepage, https://github.com/pydantic/httpx2
+Project-URL: Source, https://github.com/pydantic/httpx2/blob/main/src/httpcore2
+Author-email: Tom Christie <tom@tomchristie.com>
+Maintainer-email: "Pydantic Services Inc." <engineering@pydantic.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AnyIO
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Requires-Dist: h11>=0.16
+Requires-Dist: truststore>=0.10
+Provides-Extra: asyncio
+Requires-Dist: anyio<5.0,>=4.5.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.34.0; extra == 'trio'
+Description-Content-Type: text/markdown
+
+# HTTPCore 2
+
+[![Test Suite](https://github.com/pydantic/httpx2/workflows/Test%20Suite/badge.svg)](https://github.com/pydantic/httpx2/actions)
+[![Package version](https://badge.fury.io/py/httpcore2.svg)](https://pypi.org/project/httpcore2/)
+
+> *Do one thing, and do it well.*
+
+The HTTPCore 2 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 HTTPCore 2 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`.
+
+## Installation
+
+For HTTP/1.1 only support, install with:
+
+```shell
+pip install httpcore2
+```
+
+There are also a number of optional extras available...
+
+```shell
+pip install 'httpcore2[asyncio,trio,http2,socks]'
+```
+
+## Sending requests
+
+Send an HTTP request:
+
+```python
+import httpcore2
+
+response = httpcore2.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 `httpcore2.request()` function is provided for convenience. In practice whenever you're working with `httpcore2` you'll want to use the connection pooling functionality that it provides.
+
+```python
+import httpcore2
+
+http = httpcore2.ConnectionPool()
+response = http.request("GET", "https://www.example.com/")
+```
+
+Once you're ready to get going, [head over to the documentation](https://github.com/pydantic/httpx2/tree/main/src/httpcore2/docs).
+
+## Motivation
+
+You *probably* don't want to be using HTTPCore 2 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 `httpx2`.
+
+The motivation for `httpcore2` 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 `httpcore2` package has the following dependencies...
+
+* `h11`
+* `truststore`
+
+And the following optional extras...
+
+* `anyio` - Required by `pip install 'httpcore2[asyncio]'`.
+* `trio` - Required by `pip install 'httpcore2[trio]'`.
+* `h2` - Required by `pip install 'httpcore2[http2]'`.
+* `socksio` - Required by `pip install 'httpcore2[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:
+
+```shell
+pip install 'httpcore2==2.*'
+```
+# 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/).
+
+## 2.15.1 (October 19th, 2026)
+
+### Fixed
+
+* Configure the default SSL context once on Linux, instead of on every handshake. With OpenSSL older than 3.4, CPU usage grew over the lifetime of a reused client.
+  ([#1253](https://github.com/pydantic/httpx2/pull/1253))
+
+## 2.15.0 (October 19th, 2026)
+
+### Removed
+
+* Drop support for Python 3.10. ([#1274](https://github.com/pydantic/httpx2/pull/1274))
+
+## 2.14.0 (October 18th, 2026)
+
+### Fixed
+
+* Keep `CONNECT` and absolute-form proxy targets when the request sets the `target` extension.
+  ([#1262](https://github.com/pydantic/httpx2/pull/1262))
+* Stop blocking reads when an HTTP/2 server lowers `SETTINGS_MAX_CONCURRENT_STREAMS` while requests are in flight.
+  ([#1217](https://github.com/pydantic/httpx2/pull/1217))
+* Raise `WriteError` instead of `anyio.EndOfStream` when writing after the peer closes a TLS connection without `close_notify`.
+  ([#1263](https://github.com/pydantic/httpx2/pull/1263))
+
+## 2.13.1 (September 23rd, 2026)
+
+### Fixed
+
+* Honor the `sni_hostname` extension for TLS inside HTTP proxy tunnels without applying it to the proxy's TLS connection.
+  ([#1223](https://github.com/pydantic/httpx2/pull/1223))
+* Prefer HTTP/2 during TLS protocol negotiation when enabled, and stop advertising HTTP/1.1 when it is disabled.
+  ([#1155](https://github.com/pydantic/httpx2/pull/1155))
+
+## 2.13.0 (September 14th, 2026)
+
+### Changed
+
+* Require Trio 0.34.0 or later for the `trio` extra.
+  ([#1179](https://github.com/pydantic/httpx2/pull/1179))
+
+### Fixed
+
+* Avoid nested async generator finalization errors when streamed responses are abandoned early.
+  ([#1204](https://github.com/pydantic/httpx2/pull/1204))
+
+## 2.12.0 (August 18th, 2026)
+
+No changes since `2.11.0`. Version bumped to stay in lockstep with `httpx2`.
+
+## 2.11.0 (August 18th, 2026)
+
+### Changed
+
+* Cache sniffio availability instead of importing it on every synchronization call.
+  ([#1132](https://github.com/pydantic/httpx2/pull/1132))
+
+## 2.10.0 (August 9th, 2026)
+
+### Added
+
+* Add support for Python 3.15. ([#1090](https://github.com/pydantic/httpx2/pull/1090))
+
+### Changed
+
+* Avoid quadratic copying when sending large HTTP/2 request bodies. ([#1127](https://github.com/pydantic/httpx2/pull/1127))
+
+### Fixed
+
+* Propagate the original exception instead of raising `KeyError` when an HTTP/2 stream fails. ([#1093](https://github.com/pydantic/httpx2/pull/1093))
+* Start TLS for the `wss` scheme in SOCKS5 proxy connections. ([#1104](https://github.com/pydantic/httpx2/pull/1104))
+
+## 2.9.1 (July 24th, 2026)
+
+No changes since `2.9.0`. Version bumped to stay in lockstep with `httpx2`.
+
+## 2.9.0 (July 23rd, 2026)
+
+No changes since `2.8.0`. Version bumped to stay in lockstep with `httpx2`.
+
+## 2.8.0 (July 23rd, 2026)
+
+### Changed
+
+* Assign each released connection to a single queued request, eliminating multi-assignment churn in the connection pool. ([#1075](https://github.com/pydantic/httpx2/pull/1075))
+
+## 2.7.0 (July 14th, 2026)
+
+No changes since `2.6.0`. Version bumped to stay in lockstep with `httpx2`.
+
+## 2.6.0 (July 14th, 2026)
+
+### Fixed
+
+* Clean up garbage connections on cancellation in `AsyncConnectionPool`. ([#983](https://github.com/pydantic/httpx2/pull/983))
+* Read `_expire_at` only once in `has_expired()`. ([#1045](https://github.com/pydantic/httpx2/pull/1045))
+
+## 2.5.0 (June 25th, 2026)
+
+### Fixed
+
+* Propagate the timeout through the SOCKS5 handshake. ([#1009](https://github.com/pydantic/httpx2/pull/1009))
+
+## 2.4.0 (June 11th, 2026)
+
+### Fixed
+
+* Move HTTP/2 stream events cleanup inside `_state_lock`. ([#1013](https://github.com/pydantic/httpx2/pull/1013))
+* Release the HTTP/2 semaphore permit on `NoAvailableStreamIDError`. ([#1012](https://github.com/pydantic/httpx2/pull/1012))
+* Use `RLock` instead of `Lock` to prevent a thread deadlock. ([#1008](https://github.com/pydantic/httpx2/pull/1008))
+
+## 2.3.0 (June 1st, 2026)
+
+### Changed
+
+* Use `truststore` instead of `certifi` for default SSL verification, loading the operating system's trust store. ([#1002](https://github.com/pydantic/httpx2/pull/1002))
+* Rewrite `_assign_requests_to_connections` as a single-pass loop. ([#974](https://github.com/pydantic/httpx2/pull/974))
+* Use `anyio`'s `fast_acquire` for `Lock` and `Semaphore`. ([#970](https://github.com/pydantic/httpx2/pull/970))
+* Use `memoryview` in `write()` to avoid copies. ([#954](https://github.com/pydantic/httpx2/pull/954))
+
+## 2.2.0 (May 16th, 2026)
+
+No changes since `2.1.0`. Version bumped to stay in lockstep with `httpx2`.
+
+## 2.1.0 (May 15th, 2026)
+
+### Removed
+
+* Drop support for Python 3.8 and 3.9. ([#208](https://github.com/pydantic/httpx2/pull/208))
+
+### Added
+
+* Add support for Python 3.14. ([#208](https://github.com/pydantic/httpx2/pull/208))
+* Bundle `LICENSE.md` in the sdist. ([#938](https://github.com/pydantic/httpx2/pull/938))
+
+### Fixed
+
+* Wait for positive flow-control credit when a peer's `SETTINGS` frame drives a stream's send window negative, instead of letting h2 raise `LocalProtocolError`. ([#935](https://github.com/pydantic/httpx2/pull/935))
+
+## 2.0.0
+
+Official first release of `httpcore2`. No changes since `2.0.0b1`.
+
+## 2.0.0b1
+
+First release of `httpcore2`, a fork of [`httpcore`](https://github.com/encode/httpcore) maintained by Pydantic. Forked from `httpcore 1.0.9`.
+
+### Breaking changes
+
+* **Renamed package**: `httpcore` -> `httpcore2`. `import httpcore` becomes `import httpcore2`. No other public API changed.
+
+### Fixed
+
+* Fix `max_keepalive_connections` not being properly handled. (Inherited from upstream PR [encode/httpcore#1000](https://github.com/encode/httpcore/pull/1000).)
+
+---
+
+Historical entries below are from upstream `encode/httpcore`.
+
+## 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 dependencies. (#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 dependency, 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 dependencies. (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 resilient 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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..24e373636576c974b40ab7f1c1a61833e2679d0a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/RECORD
@@ -0,0 +1,68 @@
+httpcore2-2.15.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+httpcore2-2.15.1.dist-info/METADATA,sha256=gjRIBXpf8PuGSPBPlRg-L-_GezWzx99qgITJeMF6JMU,27442
+httpcore2-2.15.1.dist-info/RECORD,,
+httpcore2-2.15.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+httpcore2-2.15.1.dist-info/licenses/LICENSE.md,sha256=xN8SXIB7BhNQHpQ6XJJJbdEdLBZgTOOWCXqN3jljBNk,1599
+httpcore2/__init__.py,sha256=jAhvhEBbwqLtHC3PKzTQ3MZFjwnxzSTCETuB9CC5wdg,3473
+httpcore2/__pycache__/__init__.cpython-311.pyc,,
+httpcore2/__pycache__/_api.cpython-311.pyc,,
+httpcore2/__pycache__/_exceptions.cpython-311.pyc,,
+httpcore2/__pycache__/_models.cpython-311.pyc,,
+httpcore2/__pycache__/_ssl.cpython-311.pyc,,
+httpcore2/__pycache__/_synchronization.cpython-311.pyc,,
+httpcore2/__pycache__/_trace.cpython-311.pyc,,
+httpcore2/__pycache__/_utils.cpython-311.pyc,,
+httpcore2/_api.py,sha256=3xEGeZ6U2rrQsFu-9aHhBNPvdrMU7FLb3cya2ovihQs,3184
+httpcore2/_async/__init__.py,sha256=3FmsS1b2TK-nAlgpKmVGLEFigUYTtoV1CgyJq-Cl5xc,1223
+httpcore2/_async/__pycache__/__init__.cpython-311.pyc,,
+httpcore2/_async/__pycache__/connection.cpython-311.pyc,,
+httpcore2/_async/__pycache__/connection_pool.cpython-311.pyc,,
+httpcore2/_async/__pycache__/http11.cpython-311.pyc,,
+httpcore2/_async/__pycache__/http2.cpython-311.pyc,,
+httpcore2/_async/__pycache__/http_proxy.cpython-311.pyc,,
+httpcore2/_async/__pycache__/interfaces.cpython-311.pyc,,
+httpcore2/_async/__pycache__/socks_proxy.cpython-311.pyc,,
+httpcore2/_async/connection.py,sha256=nDJx7nUkp9HXgOFDqHUUxI_tPyl9BtYufFQqG74-uYA,8305
+httpcore2/_async/connection_pool.py,sha256=KiYnYlJE9oOn-TutTbL9T06Q0YwX61IMHBzVl9YWhRI,19629
+httpcore2/_async/http11.py,sha256=m8OisIV3ixcPvSK20NYfiERIqdgwHkSNEUb3JOu0KwA,13926
+httpcore2/_async/http2.py,sha256=u-SurB0YM91tcQfw8vAb7dQw8uedaZcRKjVNXSBUwxs,25120
+httpcore2/_async/http_proxy.py,sha256=srA3oSGMnmQhbjNqr6v51WoyT7UwXtqWhSGaVPQiB-Q,14937
+httpcore2/_async/interfaces.py,sha256=EJ3o4y61Q82cmm7H2IinHxJDqwO18BKyEAA5b3DLuys,5363
+httpcore2/_async/socks_proxy.py,sha256=4JJvWUsCdOmw7-Lay0O-IoVJza9g4J16vvtjYkGE7-0,13947
+httpcore2/_backends/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpcore2/_backends/__pycache__/__init__.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/anyio.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/auto.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/base.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/mock.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/sync.cpython-311.pyc,,
+httpcore2/_backends/__pycache__/trio.cpython-311.pyc,,
+httpcore2/_backends/anyio.py,sha256=PcsBhKcTaItMMwjqfzwhlbu-TspEIOL5o1tNXq7A71M,5542
+httpcore2/_backends/auto.py,sha256=NI_UX8sCgRbuxrbK-6tpaV7rgFBgOVfo6d6itTKqA3o,1642
+httpcore2/_backends/base.py,sha256=bGgfuJlHOjPZgQAlGpC4UmTCaYtrblWo3fL12HJKGTU,2997
+httpcore2/_backends/mock.py,sha256=ahbwYl2mEu5K075jTtG6jwLCVHYdVqV2mS0G4-KNQIE,4079
+httpcore2/_backends/sync.py,sha256=sFp-UsYnx7i4qLQVnPp1IPvjn3ZeNO6O5tAJ9Ot2WNM,7959
+httpcore2/_backends/trio.py,sha256=hNOqRRdRbAWmsezO8PGIC6qwvgX4Bg2SSZ7zOht14E4,5961
+httpcore2/_exceptions.py,sha256=ffKPbxfqN_qezmQ2f1B_zrYOw67kEj1K-PCNiCVTEiA,1239
+httpcore2/_models.py,sha256=gELd8jvTk-nkXzLvWIAodlG7Ep6cE0IbLj2D8BcMEGc,17422
+httpcore2/_ssl.py,sha256=GOylzyYHEDTWONSnfu6eLrgsOf_HZ_-Gj_CTDnKmbnk,1941
+httpcore2/_sync/__init__.py,sha256=AQ-tXy0gVolW_kNYfBxzR86v7C3GBSXf1TnGCtC6GhA,1143
+httpcore2/_sync/__pycache__/__init__.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/connection.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/connection_pool.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/http11.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/http2.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/http_proxy.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/interfaces.cpython-311.pyc,,
+httpcore2/_sync/__pycache__/socks_proxy.cpython-311.pyc,,
+httpcore2/_sync/connection.py,sha256=eX04TfDvqgSOjCB5YQTuydO-btvMBPrAxrUjcbmPyEE,8094
+httpcore2/_sync/connection_pool.py,sha256=6meZmb5dXO3OY7jVJTsos5btmmBuOpZC5Ubnp43zU_A,19246
+httpcore2/_sync/http11.py,sha256=2ZmbOOjU89HLNNtZKVI-9Q98ChXvteqqT86_5fkLI8c,13487
+httpcore2/_sync/http2.py,sha256=xq0NVgjRsG_uvRlQHu6618c31HovODaoGMJHJAGCXNU,24527
+httpcore2/_sync/http_proxy.py,sha256=1cnVii0dcn4r1r-Ti8TycaRKrXORTN44JNgFkFdA0R4,14699
+httpcore2/_sync/interfaces.py,sha256=a6n964OVWiQeSk01nfS6hp63EgGXibxEPhIk-Bm2eKc,5247
+httpcore2/_sync/socks_proxy.py,sha256=3rK9Bkhj7nMcq_LFzpr54pw9Gj9aWjXuHpdOEe6eeAk,13720
+httpcore2/_synchronization.py,sha256=8sMLVx3VoNnbOgf1ekif0Jcya6Z5mBQJlLFdy0klI5Q,10288
+httpcore2/_trace.py,sha256=FUYsjUcH1GK1eeWRqXaCuSYy6eA2GcwQUphLbJRQL9o,3928
+httpcore2/_utils.py,sha256=EqJIsFuBA0lXogge1JEhkdskZ7YpUeoS4SSrFtmQD0M,2533
+httpcore2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..39dc805011177e5b2a77e7afb5ec7187aeb3e34d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/licenses/LICENSE.md b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/licenses/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..88e61a11bf877529df71203f7864af2b6a250677
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2-2.15.1.dist-info/licenses/LICENSE.md
@@ -0,0 +1,28 @@
+Copyright © 2026 to present Pydantic Services Inc. and individual contributors.
+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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..708eea9ae9e7be8386c872a01226c52e221fb8f4
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__init__.py
@@ -0,0 +1,141 @@
+from importlib.metadata import version
+
+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 'httpcore2.AnyIOBackend' class is conditional on 'anyio' being installed.
+try:
+    from ._backends.anyio import AnyIOBackend
+except ImportError:  # pragma: no cover
+
+    class AnyIOBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = "Attempted to use 'httpcore2.AnyIOBackend' but 'anyio' is not installed."
+            raise RuntimeError(msg)
+
+
+# The 'httpcore2.TrioBackend' class is conditional on 'trio' being installed.
+try:
+    from ._backends.trio import TrioBackend
+except ImportError:  # pragma: no cover
+
+    class TrioBackend:  # type: ignore
+        def __init__(self, *args, **kwargs):  # type: ignore
+            msg = "Attempted to use 'httpcore2.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__ = version("httpcore2")
+
+
+__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__", "httpcore2")  # noqa
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..60a5481ce4c1a52f90a19980129b212205808665
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b9977eae8a106252f3c71bba286305793601740f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fb89fa607baf7032d2907bd81061c77f75193386
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_models.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_models.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c583e8a079f19203cea16b3565bbc52fd9857358
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_models.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_ssl.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_ssl.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e2ddf72b9afb647b10adc9f7e3535692986deb20
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_ssl.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_synchronization.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_synchronization.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d0c3e9d05dddd67d7992eca970af71e2a6eae1b9
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_synchronization.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_trace.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_trace.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..959bea772eb36d6a89eab8ac37e9e34a2e5cd33b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_trace.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44a3ebb7b24c260173a4e00adf6fa84a5980f8ed
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/__pycache__/_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7f4f228f3621bec8a0996521609a8d8c3d3e524
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_api.py
@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import Generator
+
+from ._models import URL, Extensions, HeaderTypes, Response
+from ._sync.connection_pool import ConnectionPool
+
+
+def request(
+    method: bytes | str,
+    url: URL | bytes | str,
+    *,
+    headers: HeaderTypes = None,
+    content: bytes | typing.Iterator[bytes] | None = None,
+    extensions: Extensions | None = None,
+) -> Response:
+    """
+    Sends an HTTP request, returning the response.
+
+    ```
+    response = httpcore2.request("GET", "https://www.example.com/")
+    ```
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore2.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore2.Response`.
+    """
+    with ConnectionPool() as pool:
+        return pool.request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+
+
+@contextlib.contextmanager
+def stream(
+    method: bytes | str,
+    url: URL | bytes | str,
+    *,
+    headers: HeaderTypes = None,
+    content: bytes | typing.Iterator[bytes] | None = None,
+    extensions: Extensions | None = None,
+) -> Generator[Response]:
+    """
+    Sends an HTTP request, returning the response within a content manager.
+
+    ```
+    with httpcore2.stream("GET", "https://www.example.com/") as response:
+        ...
+    ```
+
+    When using the `stream()` function, the body of the response will not be
+    automatically read. If you want to access the response body you should
+    either use `content = response.read()`, or `for chunk in response.iter_content()`.
+
+    Arguments:
+        method: The HTTP method for the request. Typically one of `"GET"`,
+            `"OPTIONS"`, `"HEAD"`, `"POST"`, `"PUT"`, `"PATCH"`, or `"DELETE"`.
+        url: The URL of the HTTP request. Either as an instance of `httpcore2.URL`,
+            or as str/bytes.
+        headers: The HTTP request headers. Either as a dictionary of str/bytes,
+            or as a list of two-tuples of str/bytes.
+        content: The content of the request body. Either as bytes,
+            or as a bytes iterator.
+        extensions: A dictionary of optional extra information included on the request.
+            Possible keys include `"timeout"`.
+
+    Returns:
+        An instance of `httpcore2.Response`.
+    """
+    with ConnectionPool() as pool:
+        with pool.stream(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        ) as response:
+            yield response
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..96b4d76ce039a6f0a12f350c14746e4b57066952
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__init__.py
@@ -0,0 +1,39 @@
+from .connection import AsyncHTTPConnection
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .http_proxy import AsyncHTTPProxy
+from .interfaces import AsyncConnectionInterface
+
+try:
+    from .http2 import AsyncHTTP2Connection
+except ImportError:  # pragma: no cover
+
+    class AsyncHTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import AsyncSOCKSProxy
+except ImportError:  # pragma: no cover
+
+    class AsyncSOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "AsyncHTTPConnection",
+    "AsyncConnectionPool",
+    "AsyncHTTPProxy",
+    "AsyncHTTP11Connection",
+    "AsyncHTTP2Connection",
+    "AsyncConnectionInterface",
+    "AsyncSOCKSProxy",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2de163f4d0ef09707186521873ec12028061f4a5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b58cbfefb2fe3d48ca8bc1a9fb43a0c2ba9f4d6a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection_pool.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection_pool.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a47789a9c69413007fad57342918ddb2b110c0ef
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/connection_pool.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http11.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http11.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f9366670688a455d930fd3b93772d8804746e758
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http11.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http2.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c93bf6056d4e2b2aba82985374f29545946c388
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http2.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http_proxy.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http_proxy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..19826c4d3ddbf7f3577308ea45ed0d4ca10a477b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/http_proxy.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/interfaces.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/interfaces.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..220c99d1f128e308bd6858b83996d3f15a9d66f6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/interfaces.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/socks_proxy.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/socks_proxy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d7f4d23a72c6cdb46c7b79655726d1e6971c8d4d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/__pycache__/socks_proxy.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..f0b445e52f5284409be4e1f3b3b7f2c847cefaaa
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection.py
@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import ssl
+import types
+import typing
+
+from .._backends.auto import AutoBackend
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
+from .._exceptions import ConnectError, ConnectTimeout
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
+
+
+logger = logging.getLogger("httpcore2.connection")
+
+
+def exponential_backoff(factor: float) -> typing.Iterator[float]:
+    """
+    Generate a geometric sequence that has a ratio of 2 and starts with 0.
+
+    For example:
+    - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...`
+    - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...`
+    """
+    yield 0
+    for n in itertools.count():
+        yield factor * 2**n
+
+
+class AsyncHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        origin: Origin,
+        ssl_context: ssl.SSLContext | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: AsyncNetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend: AsyncNetworkBackend = AutoBackend() if network_backend is None else network_backend
+        self._connection: AsyncConnectionInterface | None = None
+        self._connect_failed: bool = False
+        self._request_lock = AsyncLock()
+        self._socket_options = socket_options
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        try:
+            async with self._request_lock:
+                if self._connection is None:
+                    stream = await self._connect(request)
+
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+        except BaseException as exc:
+            self._connect_failed = True
+            raise exc
+
+        return await self._connection.handle_async_request(request)
+
+    async def _connect(self, request: Request) -> AsyncNetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        retries_left = self._retries
+        delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
+
+        while True:
+            try:
+                if self._uds is None:
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    async with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+                else:
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    async with Trace("connect_unix_socket", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_unix_socket(**kwargs)
+                        trace.return_value = stream
+
+                if self._origin.scheme in (b"https", b"wss"):
+                    ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                    alpn_protocols = (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                    ssl_context.set_alpn_protocols(alpn_protocols)
+
+                    kwargs = {
+                        "ssl_context": ssl_context,
+                        "server_hostname": sni_hostname or self._origin.host.decode("ascii"),
+                        "timeout": timeout,
+                    }
+                    async with Trace("start_tls", logger, request, kwargs) as trace:
+                        stream = await stream.start_tls(**kwargs)
+                        trace.return_value = stream
+                return stream
+            except (ConnectError, ConnectTimeout):
+                if retries_left <= 0:
+                    raise
+                retries_left -= 1
+                delay = next(delays)
+                async with Trace("retry", logger, request, kwargs) as trace:
+                    await self._network_backend.sleep(delay)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    async def aclose(self) -> None:
+        if self._connection is not None:
+            async with Trace("close", logger, None, {}):
+                await self._connection.aclose()
+
+    def is_connected(self) -> bool:
+        return self._connection is not None and self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return self._http2 and (self._origin.scheme == b"https" or not self._http1) and not self._connect_failed
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def can_multiplex(self) -> bool:
+        return self._connection is not None and self._connection.can_multiplex()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> AsyncHTTPConnection:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection_pool.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection_pool.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c5e398009048e5197a0bf085b5080af0c154d76
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/connection_pool.py
@@ -0,0 +1,440 @@
+from __future__ import annotations
+
+import ssl
+import sys
+import types
+import typing
+from collections.abc import AsyncGenerator
+
+from .._backends.auto import AutoBackend
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Proxy, Request, Response
+from .._synchronization import AsyncEvent, AsyncShieldCancellation, AsyncThreadLock
+from .._utils import safe_async_iterate
+from .connection import AsyncHTTPConnection
+from .interfaces import AsyncConnectionInterface, AsyncRequestInterface
+
+
+class AsyncPoolRequest:
+    def __init__(self, request: Request) -> None:
+        self.request = request
+        self.connection: AsyncConnectionInterface | None = None
+        self._connection_acquired = AsyncEvent()
+
+    def assign_to_connection(self, connection: AsyncConnectionInterface | None) -> None:
+        self.connection = connection
+        self._connection_acquired.set()
+
+    def clear_connection(self) -> None:
+        self.connection = None
+        self._connection_acquired = AsyncEvent()
+
+    async def wait_for_connection(self, timeout: float | None = None) -> AsyncConnectionInterface:
+        if self.connection is None:
+            await self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
+
+    def is_queued(self) -> bool:
+        return self.connection is None
+
+
+class AsyncConnectionPool(AsyncRequestInterface):
+    """
+    A connection pool for making HTTP requests.
+    """
+
+    def __init__(
+        self,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy: Proxy | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: AsyncNetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+            socket_options: Socket options that have to be included
+             in the TCP socket when the connection was established.
+        """
+        self._ssl_context = ssl_context
+        self._proxy = proxy
+        self._max_connections = sys.maxsize if max_connections is None else max_connections
+        self._max_keepalive_connections = (
+            sys.maxsize if max_keepalive_connections is None else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(self._max_connections, self._max_keepalive_connections)
+
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend = AutoBackend() if network_backend is None else network_backend
+        self._socket_options = socket_options
+
+        # The mutable state on a connection pool is the queue of incoming requests,
+        # and the set of connections that are servicing those requests.
+        self._connections: list[AsyncConnectionInterface] = []
+        self._requests: list[AsyncPoolRequest] = []
+
+        # We only mutate the state of the connection pool within an 'optional_thread_lock'
+        # context. This holds a threading lock unless we're running in async mode,
+        # in which case it is a no-op.
+        self._optional_thread_lock = AsyncThreadLock()
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        if self._proxy is not None:
+            if self._proxy.url.scheme in (b"socks5", b"socks5h"):
+                from .socks_proxy import AsyncSocks5Connection
+
+                return AsyncSocks5Connection(
+                    proxy_origin=self._proxy.url.origin,
+                    proxy_auth=self._proxy.auth,
+                    remote_origin=origin,
+                    ssl_context=self._ssl_context,
+                    keepalive_expiry=self._keepalive_expiry,
+                    http1=self._http1,
+                    http2=self._http2,
+                    network_backend=self._network_backend,
+                )
+            elif origin.scheme == b"http":
+                from .http_proxy import AsyncForwardHTTPConnection
+
+                return AsyncForwardHTTPConnection(
+                    proxy_origin=self._proxy.url.origin,
+                    proxy_headers=self._proxy.headers,
+                    proxy_ssl_context=self._proxy.ssl_context,
+                    remote_origin=origin,
+                    keepalive_expiry=self._keepalive_expiry,
+                    network_backend=self._network_backend,
+                )
+            from .http_proxy import AsyncTunnelHTTPConnection
+
+            return AsyncTunnelHTTPConnection(
+                proxy_origin=self._proxy.url.origin,
+                proxy_headers=self._proxy.headers,
+                proxy_ssl_context=self._proxy.ssl_context,
+                remote_origin=origin,
+                ssl_context=self._ssl_context,
+                keepalive_expiry=self._keepalive_expiry,
+                http1=self._http1,
+                http2=self._http2,
+                network_backend=self._network_backend,
+            )
+
+        return AsyncHTTPConnection(
+            origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            retries=self._retries,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+            socket_options=self._socket_options,
+        )
+
+    @property
+    def connections(self) -> list[AsyncConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <AsyncHTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <AsyncHTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._connections)
+
+    async def handle_async_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
+            raise UnsupportedProtocol("Request URL is missing an 'http://' or 'https://' protocol.")
+        if scheme not in ("http", "https", "ws", "wss"):
+            raise UnsupportedProtocol(f"Request URL has an unsupported protocol '{scheme}://'.")
+
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
+
+        with self._optional_thread_lock:
+            # Add the incoming request to our request queue.
+            pool_request = AsyncPoolRequest(request)
+            self._requests.append(pool_request)
+
+        try:
+            while True:
+                with self._optional_thread_lock:
+                    # Assign incoming requests to available connections,
+                    # closing or creating new connections as required.
+                    closing = self._assign_requests_to_connections()
+                await self._close_connections(closing)
+
+                # Wait until this request has an assigned connection.
+                connection = await pool_request.wait_for_connection(timeout=timeout)
+
+                try:
+                    # Send the request on the assigned connection.
+                    response = await connection.handle_async_request(pool_request.request)
+                except ConnectionNotAvailable:
+                    # In some cases a connection may initially be available to
+                    # handle a request, but then become unavailable.
+                    #
+                    # In this case we clear the connection and try again.
+                    pool_request.clear_connection()
+                else:
+                    break  # pragma: no cover
+
+        except BaseException as exc:
+            with self._optional_thread_lock:
+                # For any exception or cancellation we remove the request from
+                # the queue, and then re-assign requests to connections.
+                self._requests.remove(pool_request)
+                closing = self._assign_requests_to_connections()
+
+            await self._close_connections(closing)
+            raise exc from None
+
+        # Return the response. Note that in this case we still have to manage
+        # the point at which the response is closed.
+        assert isinstance(response.stream, typing.AsyncIterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=PoolByteStream(stream=response.stream, pool_request=pool_request, pool=self),
+            extensions=response.extensions,
+        )
+
+    def _assign_requests_to_connections(self) -> list[AsyncConnectionInterface]:
+        """
+        Manage the state of the connection pool, assigning incoming
+        requests to connections as available.
+
+        Called whenever a new request is added or removed from the pool.
+
+        Any closing connections are returned, allowing the I/O for closing
+        those connections to be handled separately.
+        """
+        closing_connections: list[AsyncConnectionInterface] = []
+        retained_connections: list[AsyncConnectionInterface] = []
+
+        # Connections currently referenced by an in-flight request, including
+        # connections that are in the process of being established and idle
+        # connections reserved by an assigned-but-not-yet-sent request.
+        request_connections = {r.connection for r in self._requests}
+
+        # First we handle cleaning up any connections that are closed
+        # or have expired their keep-alive, in a single pass. Reserved
+        # connections skip the expiry check: they were checked when assigned,
+        # and `has_expired()` on an idle connection probes the socket.
+        for connection in self._connections:
+            reserved = connection in request_connections
+            if connection.is_closed():
+                continue
+            elif not (connection.is_connected() or reserved):
+                # Garbage: a NEW-state connection whose request was cancelled
+                # before the TCP handshake completed.  Drop it without closing
+                # (there is no socket to close yet).
+                continue
+            elif not reserved and connection.has_expired():
+                closing_connections.append(connection)
+            else:
+                retained_connections.append(connection)
+
+        # Then we close any surplus idle connections, to enforce the
+        # max_keepalive_connections setting. Reserved connections are not
+        # surplus: a request is about to be sent on them.
+        idle_surplus = (
+            sum(connection.is_idle() and connection not in request_connections for connection in retained_connections)
+            - self._max_keepalive_connections
+        )
+        if idle_surplus > 0:
+            kept: list[AsyncConnectionInterface] = []
+            for connection in retained_connections:
+                if idle_surplus > 0 and connection.is_idle() and connection not in request_connections:
+                    closing_connections.append(connection)
+                    idle_surplus -= 1
+                else:
+                    kept.append(connection)
+            retained_connections = kept
+
+        self._connections = retained_connections
+
+        # Snapshot the set of reusable connections once, rather than rebuilding
+        # it per queued request — this is what brings the loop from O(N*M) to
+        # O(N+M) in the common case.
+        #
+        # An idle connection already assigned to an in-flight request is
+        # reserved: it stays IDLE until the winning task sends on it, so
+        # without this exclusion the next pass would assign it again and the
+        # loser would churn through `ConnectionNotAvailable`. Multiplexing
+        # connections are exempt: they can take further requests while idle.
+        available_connections = [
+            connection
+            for connection in self._connections
+            if connection.is_available()
+            and not (connection.is_idle() and connection in request_connections and not connection.can_multiplex())
+        ]
+        new_connection_budget = self._max_connections - len(self._connections)
+
+        # Assign queued requests to connections. Once no connection is
+        # available and no new connection may be created, no queued request
+        # can be assigned, so the scan stops early: this keeps a pass on a
+        # saturated pool O(connections) rather than O(in-flight requests).
+        for pool_request in self._requests:
+            if not available_connections and new_connection_budget <= 0:
+                break
+            if not pool_request.is_queued():
+                continue
+            origin = pool_request.request.url.origin
+
+            # There are three cases for how we may be able to handle the request:
+            #
+            # 1. There is an existing connection that can handle the request.
+            # 2. We can create a new connection to handle the request.
+            # 3. We can close an idle connection and then create a new connection
+            #    to handle the request.
+            for idx, connection in enumerate(available_connections):
+                if connection.can_handle_request(origin):
+                    pool_request.assign_to_connection(connection)
+                    if connection.is_idle() and not connection.can_multiplex():
+                        # An idle HTTP/1.1 connection can only take this
+                        # single request until it is released.
+                        del available_connections[idx]
+                    break
+            else:
+                if new_connection_budget > 0:
+                    connection = self.create_connection(origin)
+                    self._connections.append(connection)
+                    pool_request.assign_to_connection(connection)
+                    new_connection_budget -= 1
+                    continue
+                for idx, connection in enumerate(available_connections):
+                    if connection.is_idle():
+                        del available_connections[idx]
+                        self._connections.remove(connection)
+                        closing_connections.append(connection)
+                        connection = self.create_connection(origin)
+                        self._connections.append(connection)
+                        pool_request.assign_to_connection(connection)
+                        break
+
+        return closing_connections
+
+    async def _close_connections(self, closing: list[AsyncConnectionInterface]) -> None:
+        # Close connections which have been removed from the pool.
+        with AsyncShieldCancellation():
+            for connection in closing:
+                await connection.aclose()
+
+    async def aclose(self) -> None:
+        # Explicitly close the connection pool.
+        # Clears all existing requests and connections.
+        with self._optional_thread_lock:
+            closing_connections = list(self._connections)
+            self._connections = []
+        await self._close_connections(closing_connections)
+
+    async def __aenter__(self) -> AsyncConnectionPool:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        with self._optional_thread_lock:
+            request_is_queued = [request.is_queued() for request in self._requests]
+            connection_is_idle = [connection.is_idle() for connection in self._connections]
+
+            num_active_requests = request_is_queued.count(False)
+            num_queued_requests = request_is_queued.count(True)
+            num_active_connections = connection_is_idle.count(False)
+            num_idle_connections = connection_is_idle.count(True)
+
+        requests_info = f"Requests: {num_active_requests} active, {num_queued_requests} queued"
+        connection_info = f"Connections: {num_active_connections} active, {num_idle_connections} idle"
+
+        return f"<{class_name} [{requests_info} | {connection_info}]>"
+
+
+class PoolByteStream:
+    def __init__(
+        self,
+        stream: typing.AsyncIterable[bytes],
+        pool_request: AsyncPoolRequest,
+        pool: AsyncConnectionPool,
+    ) -> None:
+        self._stream = stream
+        self._pool_request = pool_request
+        self._pool = pool
+        self._closed = False
+
+    async def __aiter__(self) -> AsyncGenerator[bytes]:
+        async with safe_async_iterate(self._stream) as iterator:
+            async for chunk in iterator:
+                yield chunk
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with AsyncShieldCancellation():
+                if hasattr(self._stream, "aclose"):
+                    await self._stream.aclose()
+
+            with self._pool._optional_thread_lock:
+                self._pool._requests.remove(self._pool_request)
+                closing = self._pool._assign_requests_to_connections()
+
+            await self._pool._close_connections(closing)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http11.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http11.py
new file mode 100644
index 0000000000000000000000000000000000000000..2fc944521fc05e2d58666b71a3c00158158bea0a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http11.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import enum
+import logging
+import ssl
+import time
+import types
+import typing
+from collections.abc import AsyncGenerator
+
+import h11
+
+from .._backends.base import AsyncNetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    WriteError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock, AsyncShieldCancellation
+from .._trace import Trace
+from .._utils import safe_async_iterate
+from .interfaces import AsyncConnectionInterface
+
+logger = logging.getLogger("httpcore2.http11")
+
+
+# A subset of `h11.Event` types supported by `_send_event`
+H11SendEvent = h11.Request | h11.Data | h11.EndOfMessage
+
+
+class HTTPConnectionState(enum.IntEnum):
+    NEW = 0
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class AsyncHTTP11Connection(AsyncConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: float | None = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: float | None = keepalive_expiry
+        self._expire_at: float | None = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = AsyncLock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(
+            our_role=h11.CLIENT,
+            max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE,
+        )
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            try:
+                async with Trace("send_request_headers", logger, request, kwargs) as trace:
+                    await self._send_request_headers(**kwargs)
+                async with Trace("send_request_body", logger, request, kwargs) as trace:
+                    await self._send_request_body(**kwargs)
+            except WriteError:
+                # If we get a write error while we're writing the request,
+                # then we suppress this error and move on to attempting to
+                # read the response. Servers can sometimes close the request
+                # preemptively and then respond with a well formed HTTP
+                # error response.
+                pass
+
+            async with Trace("receive_response_headers", logger, request, kwargs) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                    trailing_data,
+                ) = await self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            network_stream = self._network_stream
+
+            # CONNECT or Upgrade request
+            if (status == 101) or ((request.method == b"CONNECT") and (200 <= status < 300)):
+                network_stream = AsyncHTTP11UpgradeStream(network_stream, trailing_data)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": network_stream,
+                },
+            )
+        except BaseException as exc:
+            with AsyncShieldCancellation():
+                async with Trace("response_closed", logger, request) as trace:
+                    await self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    async def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        await self._send_event(event, timeout=timeout)
+
+    async def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, typing.AsyncIterable)
+        async with safe_async_iterate(request.stream) as iterator:
+            async for chunk in iterator:
+                event = h11.Data(data=chunk)
+                await self._send_event(event, timeout=timeout)
+
+        await self._send_event(h11.EndOfMessage(), timeout=timeout)
+
+    async def _send_event(self, event: h11.Event, timeout: float | None = None) -> None:
+        bytes_to_send = self._h11_state.send(event)
+        if bytes_to_send is not None:
+            await self._network_stream.write(bytes_to_send, timeout=timeout)
+
+    # Receiving the response...
+
+    async def _receive_response_headers(
+        self, request: Request
+    ) -> tuple[bytes, int, bytes, list[tuple[bytes, bytes]], bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = await self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Response):
+                break
+            if isinstance(event, h11.InformationalResponse) and event.status_code == 101:
+                break
+
+        http_version = b"HTTP/" + event.http_version
+
+        # h11 version 0.11+ supports a `raw_items` interface to get the
+        # raw header casing, rather than the enforced lowercase headers.
+        headers = event.headers.raw_items()
+
+        trailing_data, _ = self._h11_state.trailing_data
+
+        return http_version, event.status_code, event.reason, headers, trailing_data
+
+    async def _receive_response_body(self, request: Request) -> AsyncGenerator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = await self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Data):
+                yield bytes(event.data)
+            elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
+                break
+
+    async def _receive_event(self, timeout: float | None = None) -> h11.Event | type[h11.PAUSED]:
+        while True:
+            with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
+                event = self._h11_state.next_event()
+
+            if event is h11.NEED_DATA:
+                data = await self._network_stream.read(self.READ_NUM_BYTES, timeout=timeout)
+
+                # If we feed this case through h11 we'll raise an exception like:
+                #
+                #     httpcore2.RemoteProtocolError: can't handle event type
+                #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
+                #
+                # Which is accurate, but not very informative from an end-user
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
+                if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
+                    msg = "Server disconnected without sending a response."
+                    raise RemoteProtocolError(msg)
+
+                self._h11_state.receive_data(data)
+            else:
+                # mypy fails to narrow the type in the above if statement above
+                return event  # type: ignore[return-value]
+
+    async def _response_closed(self) -> None:
+        async with self._state_lock:
+            if self._h11_state.our_state is h11.DONE and self._h11_state.their_state is h11.DONE:
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                await self.aclose()
+
+    # Once the connection is no longer required...
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # The AsyncConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_connected(self) -> bool:
+        return not self.is_closed()
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        # Read `_expire_at` once into a local: on free-threaded builds another
+        # thread may reset it to `None` between the check and the comparison.
+        expire_at = self._expire_at
+        keepalive_expired = expire_at is not None and now > expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = self._state == HTTPConnectionState.IDLE and self._network_stream.get_extra_info(
+            "is_readable"
+        )
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return f"{origin!r}, HTTP/1.1, {self._state.name}, Request Count: {self._request_count}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return f"<{class_name} [{origin!r}, {self._state.name}, Request Count: {self._request_count}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> AsyncHTTP11Connection:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: AsyncHTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    async def __aiter__(self) -> AsyncGenerator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            async with Trace("receive_response_body", logger, self._request, kwargs):
+                async with safe_async_iterate(self._connection._receive_response_body(**kwargs)) as iterator:
+                    async for chunk in iterator:
+                        yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with AsyncShieldCancellation():
+                await self.aclose()
+            raise exc
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            async with Trace("response_closed", logger, self._request):
+                await self._connection._response_closed()
+
+
+class AsyncHTTP11UpgradeStream(AsyncNetworkStream):
+    def __init__(self, stream: AsyncNetworkStream, leading_data: bytes) -> None:
+        self._stream = stream
+        self._leading_data = leading_data
+
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        if self._leading_data:
+            buffer = self._leading_data[:max_bytes]
+            self._leading_data = self._leading_data[max_bytes:]
+            return buffer
+        else:
+            return await self._stream.read(max_bytes, timeout)
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        await self._stream.write(buffer, timeout)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> AsyncNetworkStream:
+        return await self._stream.start_tls(ssl_context, server_hostname, timeout)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return self._stream.get_extra_info(info)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http2.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http2.py
new file mode 100644
index 0000000000000000000000000000000000000000..1044a00e46f19ab79e83c06aa4e5de23d311bab5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http2.py
@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+import enum
+import logging
+import time
+import types
+import typing
+from collections.abc import AsyncGenerator
+
+import h2.config
+import h2.connection
+import h2.events
+import h2.exceptions
+import h2.settings
+
+from .._backends.base import AsyncNetworkStream
+from .._exceptions import ConnectionNotAvailable, LocalProtocolError, RemoteProtocolError
+from .._models import Origin, Request, Response
+from .._synchronization import AsyncLock, AsyncSemaphore, AsyncShieldCancellation
+from .._trace import Trace
+from .._utils import safe_async_iterate
+from .interfaces import AsyncConnectionInterface
+
+logger = logging.getLogger("httpcore2.http2")
+
+
+def has_body_headers(request: Request) -> bool:
+    return any(k.lower() == b"content-length" or k.lower() == b"transfer-encoding" for k, _v in request.headers)
+
+
+class HTTPConnectionState(enum.IntEnum):
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class AsyncHTTP2Connection(AsyncConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: AsyncNetworkStream,
+        keepalive_expiry: float | None = None,
+    ):
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: float | None = keepalive_expiry
+        self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: float | None = None
+        self._request_count = 0
+        self._init_lock = AsyncLock()
+        self._state_lock = AsyncLock()
+        self._read_lock = AsyncLock()
+        self._write_lock = AsyncLock()
+        self._sent_connection_init = False
+        self._used_all_stream_ids = False
+        self._connection_error = False
+
+        # Mapping from stream ID to response stream events.
+        self._events: dict[
+            int,
+            list[h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded | h2.events.StreamReset,],
+        ] = {}
+
+        # Connection terminated events are stored as state since
+        # we need to handle them for all streams.
+        self._connection_terminated: h2.events.ConnectionTerminated | None = None
+
+        self._read_exception: Exception | None = None
+        self._write_exception: Exception | None = None
+
+    async def handle_async_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        async with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
+
+        async with self._init_lock:
+            if not self._sent_connection_init:
+                try:
+                    sci_kwargs = {"request": request}
+                    async with Trace("send_connection_init", logger, request, sci_kwargs):
+                        await self._send_connection_init(**sci_kwargs)
+                except BaseException as exc:
+                    with AsyncShieldCancellation():
+                        await self.aclose()
+                    raise exc
+
+                self._sent_connection_init = True
+
+                # Initially start with just 1 until the remote server provides
+                # its max_concurrent_streams value
+                self._max_streams = 1
+
+                # Revoked permits still held by active or queued requests.
+                self._max_streams_deficit = 0
+
+                local_settings_max_streams = self._h2_state.local_settings.max_concurrent_streams
+                self._max_streams_semaphore = AsyncSemaphore(local_settings_max_streams)
+
+                for _ in range(local_settings_max_streams - self._max_streams):
+                    await self._max_streams_semaphore.acquire()
+
+        # A queued request may receive a permit just before the limit drops.
+        while True:
+            await self._max_streams_semaphore.acquire()
+            with AsyncShieldCancellation():
+                async with self._state_lock:
+                    if not self._max_streams_deficit:
+                        break
+                    self._max_streams_deficit -= 1
+
+        try:
+            stream_id = self._h2_state.get_next_available_stream_id()
+            self._events[stream_id] = []
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: no cover
+            self._used_all_stream_ids = True
+            self._request_count -= 1
+            await self._max_streams_semaphore.release()
+            raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            async with Trace("send_request_headers", logger, request, kwargs):
+                await self._send_request_headers(request=request, stream_id=stream_id)
+            async with Trace("send_request_body", logger, request, kwargs):
+                await self._send_request_body(request=request, stream_id=stream_id)
+            async with Trace("receive_response_headers", logger, request, kwargs) as trace:
+                status, headers = await self._receive_response(request=request, stream_id=stream_id)
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={
+                    "http_version": b"HTTP/2",
+                    "network_stream": self._network_stream,
+                    "stream_id": stream_id,
+                },
+            )
+        except BaseException as exc:  # noqa: PIE786
+            with AsyncShieldCancellation():
+                kwargs = {"stream_id": stream_id}
+                async with Trace("response_closed", logger, request, kwargs):
+                    await self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_terminated:  # pragma: no cover
+                    raise RemoteProtocolError(self._connection_terminated)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: no cover
+
+            raise exc
+
+    async def _send_connection_init(self, request: Request) -> None:
+        """
+        The HTTP/2 connection requires some initial setup before we can start
+        using individual request/response streams on it.
+        """
+        # Need to set these manually here instead of manipulating via
+        # __setitem__() otherwise the H2Connection will emit SettingsUpdate
+        # frames in addition to sending the undesired defaults.
+        self._h2_state.local_settings = h2.settings.Settings(
+            client=True,
+            initial_values={
+                # Disable PUSH_PROMISE frames from the server since we don't do anything
+                # with them for now.  Maybe when we support caching?
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
+                # These two are taken from h2 for safe defaults
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+            },
+        )
+
+        # Some websites (*cough* Yahoo *cough*) balk at this setting being
+        # present in the initial handshake since it's not defined in the original
+        # RFC despite the RFC mandating ignoring settings you don't know about.
+        del self._h2_state.local_settings[h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL]
+
+        self._h2_state.initiate_connection()
+        self._h2_state.increment_flow_control_window(2**24)
+        await self._write_outgoing_data(request)
+
+    # Sending the request...
+
+    async def _send_request_headers(self, request: Request, stream_id: int) -> None:
+        """
+        Send the request headers to a given stream ID.
+        """
+        end_stream = not has_body_headers(request)
+
+        # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
+        # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
+        # HTTP/1.1 style headers, and map them appropriately if we end up on
+        # an HTTP/2 connection.
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
+
+        headers = [
+            (b":method", request.method),
+            (b":authority", authority),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
+        ] + [
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
+            not in (
+                b"host",
+                b"transfer-encoding",
+            )
+        ]
+
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        await self._write_outgoing_data(request)
+
+    async def _send_request_body(self, request: Request, stream_id: int) -> None:
+        """
+        Iterate over the request body sending it to a given stream ID.
+        """
+        if not has_body_headers(request):
+            return
+
+        assert isinstance(request.stream, typing.AsyncIterable)
+        async with safe_async_iterate(request.stream) as iterator:
+            async for chunk in iterator:
+                await self._send_stream_data(request, stream_id, chunk)
+
+        await self._send_end_stream(request, stream_id)
+
+    async def _send_stream_data(self, request: Request, stream_id: int, data: bytes) -> None:
+        """
+        Send a single chunk of data in one or more data frames.
+        """
+        position = 0
+        while position < len(data):
+            max_flow = await self._wait_for_outgoing_flow(request, stream_id)
+            chunk = data[position : position + max_flow]
+            position += len(chunk)
+            self._h2_state.send_data(stream_id, chunk)
+            await self._write_outgoing_data(request)
+
+    async def _send_end_stream(self, request: Request, stream_id: int) -> None:
+        """
+        Send an empty data frame on on a given stream ID with the END_STREAM flag set.
+        """
+        self._h2_state.end_stream(stream_id)
+        await self._write_outgoing_data(request)
+
+    # Receiving the response...
+
+    async def _receive_response(self, request: Request, stream_id: int) -> tuple[int, list[tuple[bytes, bytes]]]:
+        """
+        Return the response status code and headers for a given stream ID.
+        """
+        while True:
+            event = await self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.ResponseReceived):
+                break
+
+        status_code = 200
+        headers: list[tuple[bytes, bytes]] = []
+        assert event.headers is not None
+        for k, v in event.headers:
+            if k == b":status":
+                status_code = int(v.decode("ascii", errors="ignore"))
+            elif not k.startswith(b":"):
+                headers.append((k, v))
+
+        return (status_code, headers)
+
+    async def _receive_response_body(self, request: Request, stream_id: int) -> AsyncGenerator[bytes]:
+        """
+        Iterator that returns the bytes of the response body for a given stream ID.
+        """
+        while True:
+            event = await self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.DataReceived):
+                assert event.flow_controlled_length is not None
+                assert event.data is not None
+                amount = event.flow_controlled_length
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                await self._write_outgoing_data(request)
+                yield event.data
+            elif isinstance(event, h2.events.StreamEnded):
+                break
+
+    async def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded:
+        """
+        Return the next available event for a given stream ID.
+
+        Will read more data from the network if required.
+        """
+        while not self._events.get(stream_id):
+            await self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        if isinstance(event, h2.events.StreamReset):
+            raise RemoteProtocolError(event)
+        return event
+
+    async def _receive_events(self, request: Request, stream_id: int | None = None) -> None:
+        """
+        Read some data from the network until we see one or more events
+        for a given stream ID.
+        """
+        async with self._read_lock:
+            if self._connection_terminated is not None:
+                last_stream_id = self._connection_terminated.last_stream_id
+                if stream_id and last_stream_id and stream_id > last_stream_id:
+                    self._request_count -= 1
+                    raise ConnectionNotAvailable()
+                raise RemoteProtocolError(self._connection_terminated)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = await self._read_incoming_data(request)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        async with Trace("receive_remote_settings", logger, request) as trace:
+                            trace.return_value = event
+
+                    elif isinstance(
+                        event,
+                        (
+                            h2.events.ResponseReceived,
+                            h2.events.DataReceived,
+                            h2.events.StreamEnded,
+                            h2.events.StreamReset,
+                        ),
+                    ):
+                        if event.stream_id in self._events:
+                            self._events[event.stream_id].append(event)
+
+                    elif isinstance(event, h2.events.ConnectionTerminated):
+                        self._connection_terminated = event
+
+        await self._write_outgoing_data(request)
+
+    async def _receive_remote_settings_change(self, event: h2.events.RemoteSettingsChanged) -> None:
+        max_concurrent_streams = event.changed_settings.get(h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS)
+        if max_concurrent_streams:
+            new_max_streams = min(
+                max_concurrent_streams.new_value,
+                self._h2_state.local_settings.max_concurrent_streams,
+            )
+            if new_max_streams and new_max_streams != self._max_streams:
+                # Never wait for permits while holding the read lock.
+                while new_max_streams > self._max_streams:
+                    if self._max_streams_deficit > 0:
+                        self._max_streams_deficit -= 1
+                    else:
+                        await self._max_streams_semaphore.release()
+                    self._max_streams += 1
+                while new_max_streams < self._max_streams:
+                    if not self._max_streams_semaphore.acquire_if_available():
+                        self._max_streams_deficit += 1
+                    self._max_streams -= 1
+
+    async def _response_closed(self, stream_id: int) -> None:
+        async with self._state_lock:
+            if stream_id in self._events:
+                if self._max_streams_deficit > 0:
+                    self._max_streams_deficit -= 1
+                else:
+                    await self._max_streams_semaphore.release()
+                del self._events[stream_id]
+            if self._connection_terminated and not self._events:
+                await self.aclose()
+
+            elif self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: no cover
+                    await self.aclose()
+
+    async def aclose(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        await self._network_stream.aclose()
+
+    # Wrappers around network read/write operations...
+
+    async def _read_incoming_data(self, request: Request) -> list[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: no cover
+
+        try:
+            data = await self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        # Apply settings and stream admission limits atomically.
+        with AsyncShieldCancellation():
+            async with self._state_lock:
+                events: list[h2.events.Event] = self._h2_state.receive_data(data)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        await self._receive_remote_settings_change(event)
+
+        return events
+
+    async def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        async with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: no cover
+
+            try:
+                await self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: no cover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    async def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow: int = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size: int = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow <= 0:
+            await self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_connected(self) -> bool:
+        return not self.is_closed()
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+            and not (self._h2_state.state_machine.state == h2.connection.ConnectionState.CLOSED)
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        # Read `_expire_at` once into a local: on free-threaded builds another
+        # thread may reset it to `None` between the check and the comparison.
+        expire_at = self._expire_at
+        return expire_at is not None and now > expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def can_multiplex(self) -> bool:
+        return True
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return f"{origin!r}, HTTP/2, {self._state.name}, Request Count: {self._request_count}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return f"<{class_name} [{origin!r}, {self._state.name}, Request Count: {self._request_count}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    async def __aenter__(self) -> AsyncHTTP2Connection:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(self, connection: AsyncHTTP2Connection, request: Request, stream_id: int) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    async def __aiter__(self) -> AsyncGenerator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            async with Trace("receive_response_body", logger, self._request, kwargs):
+                async with safe_async_iterate(
+                    self._connection._receive_response_body(request=self._request, stream_id=self._stream_id)
+                ) as iterator:
+                    async for chunk in iterator:
+                        yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with AsyncShieldCancellation():
+                await self.aclose()
+            raise exc
+
+    async def aclose(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            async with Trace("response_closed", logger, self._request, kwargs):
+                await self._connection._response_closed(stream_id=self._stream_id)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http_proxy.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http_proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..12133e414348696b9735a0d5f8e0806272025df1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/http_proxy.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import base64
+import logging
+import ssl
+import typing
+
+from .._backends.base import SOCKET_OPTION, AsyncNetworkBackend
+from .._exceptions import ProxyError
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from .connection import AsyncHTTPConnection
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+ByteOrStr = bytes | str
+HeadersAsSequence = typing.Sequence[tuple[ByteOrStr, ByteOrStr]]
+HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr]
+
+
+logger = logging.getLogger("httpcore2.proxy")
+
+
+def merge_headers(
+    default_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+    override_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+) -> list[tuple[bytes, bytes]]:
+    """
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
+    """
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set(key.lower() for key, _value in override_headers)
+    default_headers = [(key, value) for key, value in default_headers if key.lower() not in has_override]
+    return default_headers + override_headers
+
+
+class AsyncHTTPProxy(AsyncConnectionPool):  # pragma: no cover
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: URL | bytes | str,
+        proxy_auth: tuple[bytes | str, bytes | str] | None = None,
+        proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: AsyncNetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+            socket_options=socket_options,
+        )
+
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if self._proxy_url.scheme == b"http" and proxy_ssl_context is not None:  # pragma: no cover
+            raise RuntimeError("The `proxy_ssl_context` argument is not allowed for the http scheme")
+
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            userpass = username + b":" + password
+            authorization = b"Basic " + base64.b64encode(userpass)
+            self._proxy_headers = [(b"Proxy-Authorization", authorization)] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        if origin.scheme == b"http":
+            return AsyncForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                remote_origin=origin,
+                keepalive_expiry=self._keepalive_expiry,
+                network_backend=self._network_backend,
+                proxy_ssl_context=self._proxy_ssl_context,
+            )
+        return AsyncTunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            proxy_ssl_context=self._proxy_ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class AsyncForwardHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None,
+        keepalive_expiry: float | None = None,
+        network_backend: AsyncNetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+    ) -> None:
+        self._connection = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._remote_origin = remote_origin
+
+    async def handle_async_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url) if request.url.target.startswith(b"/") else request.url.target,
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions={
+                key: value for key, value in request.extensions.items() if key not in ("sni_hostname", "target")
+            },
+        )
+        return await self._connection.handle_async_request(proxy_request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        await self._connection.aclose()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_connected(self) -> bool:
+        return self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+
+class AsyncTunnelHTTPConnection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+        proxy_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: AsyncNetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        self._connection: AsyncConnectionInterface = AsyncHTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = AsyncLock()
+        self._connected = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers([(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers)
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
+                    headers=connect_headers,
+                    extensions={
+                        key: value for key, value in request.extensions.items() if key not in ("sni_hostname", "target")
+                    },
+                )
+                connect_response = await self._connection.handle_async_request(connect_request)
+
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = f"{connect_response.status} {reason_str}"
+                    await self._connection.aclose()
+                    raise ProxyError(msg)
+
+                stream = connect_response.extensions["network_stream"]
+
+                # Upgrade the stream to SSL
+                ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                alpn_protocols = (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                server_hostname = request.extensions.get("sni_hostname") or self._remote_origin.host.decode("ascii")
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": server_hostname,
+                    "timeout": timeout,
+                }
+                async with Trace("start_tls", logger, request, kwargs) as trace:
+                    stream = await stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import AsyncHTTP2Connection
+
+                    self._connection = AsyncHTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = AsyncHTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        await self._connection.aclose()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_connected(self) -> bool:
+        return self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/interfaces.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/interfaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..008d295d4edd0db730e2eb115b70d01d56a057ff
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/interfaces.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import AsyncGenerator
+
+from .._models import (
+    URL,
+    Extensions,
+    HeaderTypes,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class AsyncRequestInterface:
+    async def request(
+        self,
+        method: bytes | str,
+        url: URL | bytes | str,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.AsyncIterator[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            await response.aread()
+        finally:
+            await response.aclose()
+        return response
+
+    @contextlib.asynccontextmanager
+    async def stream(
+        self,
+        method: bytes | str,
+        url: URL | bytes | str,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.AsyncIterator[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> AsyncGenerator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = await self.handle_async_request(request)
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    async def handle_async_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class AsyncConnectionInterface(AsyncRequestInterface):
+    async def aclose(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: no cover
+
+    def is_connected(self) -> bool:
+        """
+        Return `True` if the connection is open (the underlying socket has been
+        established).  A connection in the NEW state (just created but not yet
+        connected) returns `False`.
+
+        Note: for some implementations `is_connected() != not is_closed()`.
+        The default implementation returns `not self.is_closed()`, which is
+        correct for connections that are never in the NEW (pre-TCP) state.
+        """
+        return not self.is_closed()  # pragma: no cover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def can_multiplex(self) -> bool:
+        """
+        Return `True` if the connection can serve multiple requests
+        concurrently, such as an established HTTP/2 connection.
+
+        The default covers HTTP/1.1-style implementations, which serve a
+        single request at a time.
+        """
+        return False
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/socks_proxy.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/socks_proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..2bc347b0dc3c1ca1922de61336090d8f634bf558
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_async/socks_proxy.py
@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import logging
+import ssl
+
+import socksio
+
+from .._backends.auto import AutoBackend
+from .._backends.base import AsyncNetworkBackend, AsyncNetworkStream
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import AsyncLock
+from .._trace import Trace
+from .connection_pool import AsyncConnectionPool
+from .http11 import AsyncHTTP11Connection
+from .interfaces import AsyncConnectionInterface
+
+logger = logging.getLogger("httpcore2.socks")
+
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+async def _init_socks5_connection(
+    stream: AsyncNetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: tuple[bytes, bytes] | None = None,
+    timeouts: dict[str, float | None] | None = None,
+) -> None:
+    timeouts = timeouts or {}
+    write_timeout = timeouts.get("write", None)
+    read_timeout = timeouts.get("read", None)
+    conn = socksio.socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socksio.socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socksio.socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes, timeout=write_timeout)
+
+    # Auth method response
+    incoming_bytes = await stream.read(max_bytes=4096, timeout=read_timeout)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socksio.socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(f"Requested {requested} from proxy server, but got {responded}.")
+
+    if response.method == socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socksio.socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        await stream.write(outgoing_bytes, timeout=write_timeout)
+
+        # Username/password response
+        incoming_bytes = await stream.read(max_bytes=4096, timeout=read_timeout)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socksio.socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(socksio.socks5.SOCKS5CommandRequest.from_address(socksio.socks5.SOCKS5Command.CONNECT, (host, port)))
+    outgoing_bytes = conn.data_to_send()
+    await stream.write(outgoing_bytes, timeout=write_timeout)
+
+    # Connect response
+    incoming_bytes = await stream.read(max_bytes=4096, timeout=read_timeout)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socksio.socks5.SOCKS5Reply)
+    if response.reply_code != socksio.socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class AsyncSOCKSProxy(AsyncConnectionPool):  # pragma: no cover
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: URL | bytes | str,
+        proxy_auth: tuple[bytes | str, bytes | str] | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        network_backend: AsyncNetworkBackend | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: tuple[bytes, bytes] | None = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> AsyncConnectionInterface:
+        return AsyncSocks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class AsyncSocks5Connection(AsyncConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: tuple[bytes, bytes] | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: AsyncNetworkBackend | None = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: AsyncNetworkBackend = AutoBackend() if network_backend is None else network_backend
+        self._connect_lock = AsyncLock()
+        self._connection: AsyncConnectionInterface | None = None
+        self._connect_failed = False
+
+    async def handle_async_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        async with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    async with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = await self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                        "timeouts": timeouts,
+                    }
+                    async with Trace("setup_socks5_connection", logger, request, kwargs) as trace:
+                        await _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme in (b"https", b"wss"):
+                        ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                        alpn_protocols = (
+                            (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": sni_hostname or self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        async with Trace("start_tls", logger, request, kwargs) as trace:
+                            stream = await stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (self._http2 and not self._http1):  # pragma: no cover
+                        from .http2 import AsyncHTTP2Connection
+
+                        self._connection = AsyncHTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = AsyncHTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: no cover
+                raise ConnectionNotAvailable()
+
+        return await self._connection.handle_async_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    async def aclose(self) -> None:
+        if self._connection is not None:
+            await self._connection.aclose()
+
+    def is_connected(self) -> bool:
+        return self._connection is not None and self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2 and (self._remote_origin.scheme == b"https" or not self._http1) and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: no cover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2fa0266e1966c1f69cae092733c7fd45fa136323
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/anyio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/anyio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..64784a61e072538fb91562bf62ec21df2cf72b33
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/anyio.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/auto.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/auto.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c595efd5d0d01f6b457e45f0b8fec362871dcbbf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/auto.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/base.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..81049792f9f47582d1c3c7024e643ae8254e6c9f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/base.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/mock.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/mock.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61dfe3bf42b2239a539dbb1a71fad6fef1e70c1f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/mock.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/sync.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/sync.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e5681edc3d6c3f7ec7247fb9e24fa605e3be6ea0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/sync.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/trio.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/trio.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed8d36acf7a851e92385f5d9b775b650bb064fcf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/__pycache__/trio.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/anyio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/anyio.py
new file mode 100644
index 0000000000000000000000000000000000000000..7881a02ecc2bc01f8fa70690793a88f1d92891e3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/anyio.py
@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import ssl
+import typing
+
+import anyio
+import anyio.abc
+import anyio.streams.tls
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .._utils import is_socket_readable
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
+
+
+class AnyIOStream(AsyncNetworkStream):
+    def __init__(self, stream: anyio.abc.ByteStream) -> None:
+        self._stream = stream
+
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        exc_map: dict[type[Exception], type[Exception]] = {
+            TimeoutError: ReadTimeout,
+            anyio.BrokenResourceError: ReadError,
+            anyio.ClosedResourceError: ReadError,
+            anyio.EndOfStream: ReadError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                try:
+                    return await self._stream.receive(max_bytes=max_bytes)
+                except anyio.EndOfStream:  # pragma: no cover
+                    return b""
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        if not buffer:
+            return
+
+        exc_map: dict[type[Exception], type[Exception]] = {
+            TimeoutError: WriteTimeout,
+            anyio.BrokenResourceError: WriteError,
+            anyio.ClosedResourceError: WriteError,
+            anyio.EndOfStream: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                await self._stream.send(item=buffer)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> AsyncNetworkStream:
+        exc_map: dict[type[Exception], type[Exception]] = {
+            TimeoutError: ConnectTimeout,
+            anyio.BrokenResourceError: ConnectError,
+            anyio.EndOfStream: ConnectError,
+            ssl.SSLError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            try:
+                with anyio.fail_after(timeout):
+                    ssl_stream = await anyio.streams.tls.TLSStream.wrap(
+                        self._stream,
+                        ssl_context=ssl_context,
+                        hostname=server_hostname,
+                        standard_compatible=False,
+                        server_side=False,
+                    )
+            except Exception as exc:  # pragma: no cover
+                await self.aclose()
+                raise exc
+        return AnyIOStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object":
+            return self._stream.extra(anyio.streams.tls.TLSAttribute.ssl_object, None)
+        if info == "client_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.local_address, None)
+        if info == "server_addr":
+            return self._stream.extra(anyio.abc.SocketAttribute.remote_address, None)
+        if info == "socket":
+            return self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+        if info == "is_readable":
+            sock = self._stream.extra(anyio.abc.SocketAttribute.raw_socket, None)
+            return is_socket_readable(sock)
+        return None
+
+
+class AnyIOBackend(AsyncNetworkBackend):
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:  # pragma: no cover
+        if socket_options is None:
+            socket_options = []
+        exc_map: dict[type[Exception], type[Exception]] = {
+            TimeoutError: ConnectTimeout,
+            OSError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                stream: anyio.abc.ByteStream = await anyio.connect_tcp(
+                    remote_host=host,
+                    remote_port=port,
+                    local_host=local_address,
+                )
+                # By default TCP sockets opened in `asyncio` include TCP_NODELAY.
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return AnyIOStream(stream)
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:  # pragma: no cover
+        if socket_options is None:
+            socket_options = []
+        exc_map: dict[type[Exception], type[Exception]] = {
+            TimeoutError: ConnectTimeout,
+            OSError: ConnectError,
+            anyio.BrokenResourceError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with anyio.fail_after(timeout):
+                stream: anyio.abc.ByteStream = await anyio.connect_unix(path)
+                for option in socket_options:
+                    stream._raw_socket.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return AnyIOStream(stream)
+
+    async def sleep(self, seconds: float) -> None:
+        await anyio.sleep(seconds)  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/auto.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/auto.py
new file mode 100644
index 0000000000000000000000000000000000000000..c946c9e655d453f82cd4f11371cf5e218cd158ef
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/auto.py
@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import typing
+
+from .._synchronization import current_async_library
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
+
+
+class AutoBackend(AsyncNetworkBackend):
+    async def _init_backend(self) -> None:
+        if not (hasattr(self, "_backend")):
+            backend = current_async_library()
+            if backend == "trio":
+                from .trio import TrioBackend
+
+                self._backend: AsyncNetworkBackend = TrioBackend()
+            else:
+                from .anyio import AnyIOBackend
+
+                self._backend = AnyIOBackend()
+
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        await self._init_backend()
+        return await self._backend.connect_tcp(
+            host,
+            port,
+            timeout=timeout,
+            local_address=local_address,
+            socket_options=socket_options,
+        )
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:  # pragma: no cover
+        await self._init_backend()
+        return await self._backend.connect_unix_socket(path, timeout=timeout, socket_options=socket_options)
+
+    async def sleep(self, seconds: float) -> None:  # pragma: no cover
+        await self._init_backend()
+        return await self._backend.sleep(seconds)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/base.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..da0d72dbbc80c7b0e6d730370330ea59b5b8a5c9
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/base.py
@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import ssl
+import time
+import typing
+
+SOCKET_OPTION = tuple[int, int, int] | tuple[int, int, bytes | bytearray] | tuple[int, int, None, int]
+
+
+class NetworkStream:
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        raise NotImplementedError()  # pragma: no cover
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: no cover
+
+
+class NetworkBackend:
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    def sleep(self, seconds: float) -> None:
+        time.sleep(seconds)  # pragma: no cover
+
+
+class AsyncNetworkStream:
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def aclose(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return None  # pragma: no cover
+
+
+class AsyncNetworkBackend:
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        raise NotImplementedError()  # pragma: no cover
+
+    async def sleep(self, seconds: float) -> None:
+        raise NotImplementedError()  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/mock.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/mock.py
new file mode 100644
index 0000000000000000000000000000000000000000..d710782cd72cdb6ffbc8544492b77d9a76286328
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/mock.py
@@ -0,0 +1,143 @@
+from __future__ import annotations
+
+import ssl
+import typing
+
+from .._exceptions import ReadError
+from .base import (
+    SOCKET_OPTION,
+    AsyncNetworkBackend,
+    AsyncNetworkStream,
+    NetworkBackend,
+    NetworkStream,
+)
+
+
+class MockSSLObject:
+    def __init__(self, http2: bool):
+        self._http2 = http2
+
+    def selected_alpn_protocol(self) -> str:
+        return "h2" if self._http2 else "http/1.1"
+
+
+class MockStream(NetworkStream):
+    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+        self._closed = False
+
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        if self._closed:
+            raise ReadError("Connection closed")
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        pass
+
+    def close(self) -> None:
+        self._closed = True
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> NetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+    def __repr__(self) -> str:
+        return "<httpcore2.MockStream>"
+
+
+class MockBackend(NetworkBackend):
+    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:
+        return MockStream(list(self._buffer), http2=self._http2)
+
+    def sleep(self, seconds: float) -> None:
+        pass
+
+
+class AsyncMockStream(AsyncNetworkStream):
+    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+        self._closed = False
+
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        if self._closed:
+            raise ReadError("Connection closed")
+        if not self._buffer:
+            return b""
+        return self._buffer.pop(0)
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        pass
+
+    async def aclose(self) -> None:
+        self._closed = True
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> AsyncNetworkStream:
+        return self
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return MockSSLObject(http2=self._http2) if info == "ssl_object" else None
+
+    def __repr__(self) -> str:
+        return "<httpcore2.AsyncMockStream>"
+
+
+class AsyncMockBackend(AsyncNetworkBackend):
+    def __init__(self, buffer: list[bytes], http2: bool = False) -> None:
+        self._buffer = buffer
+        self._http2 = http2
+
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        return AsyncMockStream(list(self._buffer), http2=self._http2)
+
+    async def sleep(self, seconds: float) -> None:
+        pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/sync.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/sync.py
new file mode 100644
index 0000000000000000000000000000000000000000..54ce5428c4b86361b075ed7b6b6f5e26aa936c95
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/sync.py
@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import functools
+import socket
+import ssl
+import sys
+import typing
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ExceptionMapping,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .._utils import is_socket_readable
+from .base import SOCKET_OPTION, NetworkBackend, NetworkStream
+
+
+class TLSinTLSStream(NetworkStream):  # pragma: no cover
+    """
+    Because the standard `SSLContext.wrap_socket` method does
+    not work for `SSLSocket` objects, we need this class
+    to implement TLS stream using an underlying `SSLObject`
+    instance in order to support TLS on top of TLS.
+    """
+
+    # Defined in RFC 8449
+    TLS_RECORD_SIZE = 16384
+
+    def __init__(
+        self,
+        sock: socket.socket,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ):
+        self._sock = sock
+        self._incoming = ssl.MemoryBIO()
+        self._outgoing = ssl.MemoryBIO()
+
+        self.ssl_obj = ssl_context.wrap_bio(
+            incoming=self._incoming,
+            outgoing=self._outgoing,
+            server_hostname=server_hostname,
+        )
+
+        self._sock.settimeout(timeout)
+        self._perform_io(self.ssl_obj.do_handshake)
+
+    def _perform_io(
+        self,
+        func: typing.Callable[..., typing.Any],
+    ) -> typing.Any:
+        ret = None
+
+        while True:
+            errno = None
+            try:
+                ret = func()
+            except (ssl.SSLWantReadError, ssl.SSLWantWriteError) as e:
+                errno = e.errno
+
+            self._sock.sendall(self._outgoing.read())
+
+            if errno == ssl.SSL_ERROR_WANT_READ:
+                buf = self._sock.recv(self.TLS_RECORD_SIZE)
+
+                if buf:
+                    self._incoming.write(buf)
+                else:
+                    self._incoming.write_eof()
+            if errno is None:
+                return ret
+
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            return typing.cast(bytes, self._perform_io(functools.partial(self.ssl_obj.read, max_bytes)))
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            view = memoryview(buffer)  # zero-copy slicing; avoids copies
+            while view:
+                nsent = self._perform_io(functools.partial(self.ssl_obj.write, view))
+                view = view[nsent:]
+
+    def close(self) -> None:
+        self._sock.close()
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> NetworkStream:
+        raise NotImplementedError()
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object":
+            return self.ssl_obj
+        if info == "client_addr":
+            return self._sock.getsockname()
+        if info == "server_addr":
+            return self._sock.getpeername()
+        if info == "socket":
+            return self._sock
+        if info == "is_readable":
+            return is_socket_readable(self._sock)
+        return None
+
+
+class SyncStream(NetworkStream):
+    def __init__(self, sock: socket.socket) -> None:
+        self._sock = sock
+
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        exc_map: ExceptionMapping = {socket.timeout: ReadTimeout, OSError: ReadError}
+        with map_exceptions(exc_map):
+            self._sock.settimeout(timeout)
+            return self._sock.recv(max_bytes)
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        if not buffer:
+            return
+
+        exc_map: ExceptionMapping = {socket.timeout: WriteTimeout, OSError: WriteError}
+        with map_exceptions(exc_map):
+            view = memoryview(buffer)  # zero-copy slicing; avoids copies
+            while view:
+                self._sock.settimeout(timeout)
+                n = self._sock.send(view)
+                view = view[n:]
+
+    def close(self) -> None:
+        self._sock.close()
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> NetworkStream:
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            try:
+                if isinstance(self._sock, ssl.SSLSocket):  # pragma: no cover
+                    # If the underlying socket has already been upgraded
+                    # to the TLS layer (i.e. is an instance of SSLSocket),
+                    # we need some additional smarts to support TLS-in-TLS.
+                    return TLSinTLSStream(self._sock, ssl_context, server_hostname, timeout)
+                else:
+                    self._sock.settimeout(timeout)
+                    sock = ssl_context.wrap_socket(self._sock, server_hostname=server_hostname)
+            except Exception as exc:  # pragma: no cover
+                self.close()
+                raise exc
+        return SyncStream(sock)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._sock, ssl.SSLSocket):
+            return self._sock._sslobj  # type: ignore
+        if info == "client_addr":
+            return self._sock.getsockname()
+        if info == "server_addr":
+            return self._sock.getpeername()
+        if info == "socket":
+            return self._sock
+        if info == "is_readable":
+            return is_socket_readable(self._sock)
+        return None
+
+
+class SyncBackend(NetworkBackend):
+    def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:
+        # Note that we automatically include `TCP_NODELAY`
+        # in addition to any other custom socket options.
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
+        address = (host, port)
+        source_address = None if local_address is None else (local_address, 0)
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
+
+        with map_exceptions(exc_map):
+            sock = socket.create_connection(
+                address,
+                timeout,
+                source_address=source_address,
+            )
+            for option in socket_options:
+                sock.setsockopt(*option)  # pragma: no cover
+            sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        return SyncStream(sock)
+
+    def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> NetworkStream:  # pragma: no cover
+        if sys.platform == "win32":
+            raise RuntimeError("Attempted to connect to a UNIX socket on a Windows system.")
+        if socket_options is None:
+            socket_options = []
+
+        exc_map: ExceptionMapping = {
+            socket.timeout: ConnectTimeout,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            for option in socket_options:
+                sock.setsockopt(*option)
+            sock.settimeout(timeout)
+            sock.connect(path)
+        return SyncStream(sock)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/trio.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/trio.py
new file mode 100644
index 0000000000000000000000000000000000000000..742985b9b5211beb48e3606a66f22654fd58e4cd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_backends/trio.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+import ssl
+import typing
+
+import trio
+
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    ExceptionMapping,
+    ReadError,
+    ReadTimeout,
+    WriteError,
+    WriteTimeout,
+    map_exceptions,
+)
+from .base import SOCKET_OPTION, AsyncNetworkBackend, AsyncNetworkStream
+
+
+class TrioStream(AsyncNetworkStream):
+    def __init__(self, stream: trio.abc.Stream) -> None:
+        self._stream = stream
+
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: ReadTimeout,
+            trio.BrokenResourceError: ReadError,
+            trio.ClosedResourceError: ReadError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                data: bytes = await self._stream.receive_some(max_bytes=max_bytes)
+                return data
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        if not buffer:
+            return
+
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: WriteTimeout,
+            trio.BrokenResourceError: WriteError,
+            trio.ClosedResourceError: WriteError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                await self._stream.send_all(data=buffer)
+
+    async def aclose(self) -> None:
+        await self._stream.aclose()
+
+    async def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> AsyncNetworkStream:
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+        }
+        ssl_stream = trio.SSLStream(
+            self._stream,
+            ssl_context=ssl_context,
+            server_hostname=server_hostname,
+            https_compatible=True,
+            server_side=False,
+        )
+        with map_exceptions(exc_map):
+            try:
+                with trio.fail_after(timeout_or_inf):
+                    await ssl_stream.do_handshake()
+            except Exception as exc:  # pragma: no cover
+                await self.aclose()
+                raise exc
+        return TrioStream(ssl_stream)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        if info == "ssl_object" and isinstance(self._stream, trio.SSLStream):
+            # Type checkers cannot see `_ssl_object` attribute because trio._ssl.SSLStream uses __getattr__/__setattr__.
+            # Tracked at https://github.com/python-trio/trio/issues/542
+            return self._stream._ssl_object  # type: ignore[attr-defined]
+        if info == "client_addr":
+            return self._get_socket_stream().socket.getsockname()
+        if info == "server_addr":
+            return self._get_socket_stream().socket.getpeername()
+        if info == "socket":
+            stream = self._stream
+            while isinstance(stream, trio.SSLStream):
+                stream = stream.transport_stream
+            assert isinstance(stream, trio.SocketStream)
+            return stream.socket
+        if info == "is_readable":
+            socket = self.get_extra_info("socket")
+            return socket.is_readable()
+        return None
+
+    def _get_socket_stream(self) -> trio.SocketStream:
+        stream = self._stream
+        while isinstance(stream, trio.SSLStream):
+            stream = stream.transport_stream
+        assert isinstance(stream, trio.SocketStream)
+        return stream
+
+
+class TrioBackend(AsyncNetworkBackend):
+    async def connect_tcp(
+        self,
+        host: str,
+        port: int,
+        timeout: float | None = None,
+        local_address: str | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:
+        # By default for TCP sockets, trio enables TCP_NODELAY.
+        # https://trio.readthedocs.io/en/stable/reference-io.html#trio.SocketStream
+        if socket_options is None:
+            socket_options = []  # pragma: no cover
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                stream: trio.abc.Stream = await trio.open_tcp_stream(host=host, port=port, local_address=local_address)
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return TrioStream(stream)
+
+    async def connect_unix_socket(
+        self,
+        path: str,
+        timeout: float | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> AsyncNetworkStream:  # pragma: no cover
+        if socket_options is None:
+            socket_options = []
+        timeout_or_inf = float("inf") if timeout is None else timeout
+        exc_map: ExceptionMapping = {
+            trio.TooSlowError: ConnectTimeout,
+            trio.BrokenResourceError: ConnectError,
+            OSError: ConnectError,
+        }
+        with map_exceptions(exc_map):
+            with trio.fail_after(timeout_or_inf):
+                stream: trio.abc.Stream = await trio.open_unix_socket(path)
+                for option in socket_options:
+                    stream.setsockopt(*option)  # type: ignore[attr-defined] # pragma: no cover
+        return TrioStream(stream)
+
+    async def sleep(self, seconds: float) -> None:
+        await trio.sleep(seconds)  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..a54d43b75cf6af20ee36e28da6a1287fbef0eb9f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_exceptions.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import Generator
+
+ExceptionMapping = typing.Mapping[type[Exception], type[Exception]]
+
+
+@contextlib.contextmanager
+def map_exceptions(map: ExceptionMapping) -> Generator[None]:
+    try:
+        yield
+    except Exception as exc:  # noqa: PIE786
+        for from_exc, to_exc in map.items():
+            if isinstance(exc, from_exc):
+                raise to_exc(exc) from exc
+        raise  # pragma: no cover
+
+
+class ConnectionNotAvailable(Exception):
+    pass
+
+
+class ProxyError(Exception):
+    pass
+
+
+class UnsupportedProtocol(Exception):
+    pass
+
+
+class ProtocolError(Exception):
+    pass
+
+
+class RemoteProtocolError(ProtocolError):
+    pass
+
+
+class LocalProtocolError(ProtocolError):
+    pass
+
+
+# Timeout errors
+
+
+class TimeoutException(Exception):
+    pass
+
+
+class PoolTimeout(TimeoutException):
+    pass
+
+
+class ConnectTimeout(TimeoutException):
+    pass
+
+
+class ReadTimeout(TimeoutException):
+    pass
+
+
+class WriteTimeout(TimeoutException):
+    pass
+
+
+# Network errors
+
+
+class NetworkError(Exception):
+    pass
+
+
+class ConnectError(NetworkError):
+    pass
+
+
+class ReadError(NetworkError):
+    pass
+
+
+class WriteError(NetworkError):
+    pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_models.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..c8e4f0c9a45135867948ceed47bb15bf8c3acb98
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_models.py
@@ -0,0 +1,490 @@
+from __future__ import annotations
+
+import base64
+import ssl
+import typing
+import urllib.parse
+from collections.abc import AsyncGenerator
+
+from ._utils import safe_async_iterate
+
+# Functions for typechecking...
+
+
+ByteOrStr = bytes | str
+HeadersAsSequence = typing.Sequence[tuple[ByteOrStr, ByteOrStr]]
+HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr]
+HeaderTypes = HeadersAsSequence | HeadersAsMapping | None
+
+Extensions = typing.MutableMapping[str, typing.Any]
+
+
+def enforce_bytes(value: bytes | str, *, name: str) -> bytes:
+    """
+    Any arguments that are ultimately represented as bytes can be specified
+    either as bytes or as strings.
+
+    However we enforce that any string arguments must only contain characters in
+    the plain ASCII range. chr(0)...chr(127). If you need to use characters
+    outside that range then be precise, and use a byte-wise argument.
+    """
+    if isinstance(value, str):
+        try:
+            return value.encode("ascii")
+        except UnicodeEncodeError:
+            raise TypeError(f"{name} strings may not include unicode characters.")
+    elif isinstance(value, bytes):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be bytes or str, but got {seen_type}.")
+
+
+def enforce_url(value: URL | bytes | str, *, name: str) -> URL:
+    """
+    Type check for URL parameters.
+    """
+    if isinstance(value, (bytes, str)):
+        return URL(value)
+    elif isinstance(value, URL):
+        return value
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be a URL, bytes, or str, but got {seen_type}.")
+
+
+def enforce_headers(
+    value: HeadersAsMapping | HeadersAsSequence | None = None, *, name: str
+) -> list[tuple[bytes, bytes]]:
+    """
+    Convenience function that ensure all items in request or response headers
+    are either bytes or strings in the plain ASCII range.
+    """
+    if value is None:
+        return []
+    elif isinstance(value, typing.Mapping):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value.items()
+        ]
+    elif isinstance(value, typing.Sequence):
+        return [
+            (
+                enforce_bytes(k, name="header name"),
+                enforce_bytes(v, name="header value"),
+            )
+            for k, v in value
+        ]
+
+    seen_type = type(value).__name__
+    raise TypeError(f"{name} must be a mapping or sequence of two-tuples, but got {seen_type}.")
+
+
+def enforce_stream(
+    value: bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes] | None,
+    *,
+    name: str,
+) -> typing.Iterable[bytes] | typing.AsyncIterable[bytes]:
+    if value is None:
+        return ByteStream(b"")
+    elif isinstance(value, bytes):
+        return ByteStream(value)
+    return value
+
+
+# * https://tools.ietf.org/html/rfc3986#section-3.2.3
+# * https://url.spec.whatwg.org/#url-miscellaneous
+# * https://url.spec.whatwg.org/#scheme-state
+DEFAULT_PORTS = {
+    b"ftp": 21,
+    b"http": 80,
+    b"https": 443,
+    b"ws": 80,
+    b"wss": 443,
+}
+
+
+def include_request_headers(
+    headers: list[tuple[bytes, bytes]],
+    *,
+    url: URL,
+    content: None | bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes],
+) -> list[tuple[bytes, bytes]]:
+    headers_set = {k.lower() for k, _v in headers}
+
+    if b"host" not in headers_set:
+        default_port = DEFAULT_PORTS.get(url.scheme)
+        if url.port is None or url.port == default_port:
+            header_value = url.host
+        else:
+            header_value = b"%b:%d" % (url.host, url.port)
+        headers = [(b"Host", header_value)] + headers
+
+    if content is not None and b"content-length" not in headers_set and b"transfer-encoding" not in headers_set:
+        if isinstance(content, bytes):
+            content_length = str(len(content)).encode("ascii")
+            headers += [(b"Content-Length", content_length)]
+        else:
+            headers += [(b"Transfer-Encoding", b"chunked")]  # pragma: no cover
+
+    return headers
+
+
+# Interfaces for byte streams...
+
+
+class ByteStream:
+    """
+    A container for non-streaming content, and that supports both sync and async
+    stream iteration.
+    """
+
+    def __init__(self, content: bytes) -> None:
+        self._content = content
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        yield self._content
+
+    async def __aiter__(self) -> AsyncGenerator[bytes]:
+        yield self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{len(self._content)} bytes]>"
+
+
+class Origin:
+    def __init__(self, scheme: bytes, host: bytes, port: int) -> None:
+        self.scheme = scheme
+        self.host = host
+        self.port = port
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, Origin)
+            and self.scheme == other.scheme
+            and self.host == other.host
+            and self.port == other.port
+        )
+
+    def __str__(self) -> str:
+        scheme = self.scheme.decode("ascii")
+        host = self.host.decode("ascii")
+        port = str(self.port)
+        return f"{scheme}://{host}:{port}"
+
+
+class URL:
+    """
+    Represents the URL against which an HTTP request may be made.
+
+    The URL may either be specified as a plain string, for convenience:
+
+    ```python
+    url = httpcore2.URL("https://www.example.com/")
+    ```
+
+    Or be constructed with explicitly pre-parsed components:
+
+    ```python
+    url = httpcore2.URL(scheme=b'https', host=b'www.example.com', port=None, target=b'/')
+    ```
+
+    Using this second more explicit style allows integrations that are using
+    `httpcore` to pass through URLs that have already been parsed in order to use
+    libraries such as `rfc-3986` rather than relying on the stdlib. It also ensures
+    that URL parsing is treated identically at both the networking level and at any
+    higher layers of abstraction.
+
+    The four components are important here, as they allow the URL to be precisely
+    specified in a pre-parsed format. They also allow certain types of request to
+    be created that could not otherwise be expressed.
+
+    For example, an HTTP request to `http://www.example.com/` forwarded via a proxy
+    at `http://localhost:8080`...
+
+    ```python
+    # Constructs an HTTP request with a complete URL as the target:
+    # GET https://www.example.com/ HTTP/1.1
+    url = httpcore2.URL(
+        scheme=b'http',
+        host=b'localhost',
+        port=8080,
+        target=b'https://www.example.com/'
+    )
+    request = httpcore2.Request(
+        method="GET",
+        url=url
+    )
+    ```
+
+    Another example is constructing an `OPTIONS *` request...
+
+    ```python
+    # Constructs an 'OPTIONS *' HTTP request:
+    # OPTIONS * HTTP/1.1
+    url = httpcore2.URL(scheme=b'https', host=b'www.example.com', target=b'*')
+    request = httpcore2.Request(method="OPTIONS", url=url)
+    ```
+
+    This kind of request is not possible to formulate with a URL string,
+    because the `/` delimiter is always used to demark the target from the
+    host/port portion of the URL.
+
+    For convenience, string-like arguments may be specified either as strings or
+    as bytes. However, once a request is being issue over-the-wire, the URL
+    components are always ultimately required to be a bytewise representation.
+
+    In order to avoid any ambiguity over character encodings, when strings are used
+    as arguments, they must be strictly limited to the ASCII range `chr(0)`-`chr(127)`.
+    If you require a bytewise representation that is outside this range you must
+    handle the character encoding directly, and pass a bytes instance.
+    """
+
+    def __init__(
+        self,
+        url: bytes | str = "",
+        *,
+        scheme: bytes | str = b"",
+        host: bytes | str = b"",
+        port: int | None = None,
+        target: bytes | str = b"",
+    ) -> None:
+        """
+        Parameters:
+            url: The complete URL as a string or bytes.
+            scheme: The URL scheme as a string or bytes.
+                Typically either `"http"` or `"https"`.
+            host: The URL host as a string or bytes. Such as `"www.example.com"`.
+            port: The port to connect to. Either an integer or `None`.
+            target: The target of the HTTP request. Such as `"/items?search=red"`.
+        """
+        if url:
+            parsed = urllib.parse.urlparse(enforce_bytes(url, name="url"))
+            self.scheme = parsed.scheme
+            self.host = parsed.hostname or b""
+            self.port = parsed.port
+            self.target = (parsed.path or b"/") + (b"?" + parsed.query if parsed.query else b"")
+        else:
+            self.scheme = enforce_bytes(scheme, name="scheme")
+            self.host = enforce_bytes(host, name="host")
+            self.port = port
+            self.target = enforce_bytes(target, name="target")
+
+    @property
+    def origin(self) -> Origin:
+        default_port = {
+            b"http": 80,
+            b"https": 443,
+            b"ws": 80,
+            b"wss": 443,
+            b"socks5": 1080,
+            b"socks5h": 1080,
+        }[self.scheme]
+        return Origin(scheme=self.scheme, host=self.host, port=self.port or default_port)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return (
+            isinstance(other, URL)
+            and other.scheme == self.scheme
+            and other.host == self.host
+            and other.port == self.port
+            and other.target == self.target
+        )
+
+    def __bytes__(self) -> bytes:
+        if self.port is None:
+            return b"%b://%b%b" % (self.scheme, self.host, self.target)
+        return b"%b://%b:%d%b" % (self.scheme, self.host, self.port, self.target)
+
+    def __repr__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(scheme={self.scheme!r}, "
+            f"host={self.host!r}, port={self.port!r}, target={self.target!r})"
+        )
+
+
+class Request:
+    """
+    An HTTP request.
+    """
+
+    def __init__(
+        self,
+        method: bytes | str,
+        url: URL | bytes | str,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> None:
+        """
+        Parameters:
+            method: The HTTP request method, either as a string or bytes.
+                For example: `GET`.
+            url: The request URL, either as a `URL` instance, or as a string or bytes.
+                For example: `"https://www.example.com".`
+            headers: The HTTP request headers.
+            content: The content of the request body.
+            extensions: A dictionary of optional extra information included on
+                the request. Possible keys include `"timeout"`, and `"trace"`.
+        """
+        self.method: bytes = enforce_bytes(method, name="method")
+        self.url: URL = enforce_url(url, name="url")
+        self.headers: list[tuple[bytes, bytes]] = enforce_headers(headers, name="headers")
+        self.stream: typing.Iterable[bytes] | typing.AsyncIterable[bytes] = enforce_stream(content, name="content")
+        self.extensions = {} if extensions is None else extensions
+
+        if "target" in self.extensions:
+            self.url = URL(
+                scheme=self.url.scheme,
+                host=self.url.host,
+                port=self.url.port,
+                target=self.extensions["target"],
+            )
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.method!r}]>"
+
+
+class Response:
+    """
+    An HTTP response.
+    """
+
+    def __init__(
+        self,
+        status: int,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.Iterable[bytes] | typing.AsyncIterable[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> None:
+        """
+        Parameters:
+            status: The HTTP status code of the response. For example `200`.
+            headers: The HTTP response headers.
+            content: The content of the response body.
+            extensions: A dictionary of optional extra information included on
+                the responseself.Possible keys include `"http_version"`,
+                `"reason_phrase"`, and `"network_stream"`.
+        """
+        self.status: int = status
+        self.headers: list[tuple[bytes, bytes]] = enforce_headers(headers, name="headers")
+        self.stream: typing.Iterable[bytes] | typing.AsyncIterable[bytes] = enforce_stream(content, name="content")
+        self.extensions = {} if extensions is None else extensions
+
+        self._stream_consumed = False
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            if isinstance(self.stream, typing.Iterable):
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. Call 'response.read()' first."
+                )
+            else:
+                raise RuntimeError(
+                    "Attempted to access 'response.content' on a streaming response. "
+                    "Call 'await response.aread()' first."
+                )
+        return self._content
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.status}]>"
+
+    # Sync interface...
+
+    def read(self) -> bytes:
+        if not isinstance(self.stream, typing.Iterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to read an asynchronous response using 'response.read()'. "
+                "You should use 'await response.aread()' instead."
+            )
+        if not hasattr(self, "_content"):
+            self._content = b"".join(list(self.iter_stream()))
+        return self._content
+
+    def iter_stream(self) -> typing.Iterator[bytes]:
+        if not isinstance(self.stream, typing.Iterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to stream an asynchronous response using 'for ... in "
+                "response.iter_stream()'. "
+                "You should use 'async for ... in response.aiter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError("Attempted to call 'for ... in response.iter_stream()' more than once.")
+        self._stream_consumed = True
+        yield from self.stream
+
+    def close(self) -> None:
+        if not isinstance(self.stream, typing.Iterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to close an asynchronous response using 'response.close()'. "
+                "You should use 'await response.aclose()' instead."
+            )
+        if hasattr(self.stream, "close"):
+            self.stream.close()
+
+    # Async interface...
+
+    async def aread(self) -> bytes:
+        if not isinstance(self.stream, typing.AsyncIterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to read an synchronous response using "
+                "'await response.aread()'. "
+                "You should use 'response.read()' instead."
+            )
+        if not hasattr(self, "_content"):
+            async with safe_async_iterate(self.aiter_stream()) as parts:
+                self._content = b"".join([part async for part in parts])
+        return self._content
+
+    async def aiter_stream(self) -> AsyncGenerator[bytes]:
+        if not isinstance(self.stream, typing.AsyncIterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to stream an synchronous response using 'async for ... in "
+                "response.aiter_stream()'. "
+                "You should use 'for ... in response.iter_stream()' instead."
+            )
+        if self._stream_consumed:
+            raise RuntimeError("Attempted to call 'async for ... in response.aiter_stream()' more than once.")
+        self._stream_consumed = True
+        async with safe_async_iterate(self.stream) as iterator:
+            async for chunk in iterator:
+                yield chunk
+
+    async def aclose(self) -> None:
+        if not isinstance(self.stream, typing.AsyncIterable):  # pragma: no cover
+            raise RuntimeError(
+                "Attempted to close a synchronous response using "
+                "'await response.aclose()'. "
+                "You should use 'response.close()' instead."
+            )
+        if hasattr(self.stream, "aclose"):
+            await self.stream.aclose()
+
+
+class Proxy:
+    def __init__(
+        self,
+        url: URL | bytes | str,
+        auth: tuple[bytes | str, bytes | str] | None = None,
+        headers: HeadersAsMapping | HeadersAsSequence | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+    ):
+        self.url = enforce_url(url, name="url")
+        self.headers = enforce_headers(headers, name="headers")
+        self.ssl_context = ssl_context
+
+        if auth is not None:
+            username = enforce_bytes(auth[0], name="auth")
+            password = enforce_bytes(auth[1], name="auth")
+            userpass = username + b":" + password
+            authorization = b"Basic " + base64.b64encode(userpass)
+            self.auth: tuple[bytes, bytes] | None = (username, password)
+            self.headers = [(b"Proxy-Authorization", authorization)] + self.headers
+        else:
+            self.auth = None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_ssl.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_ssl.py
new file mode 100644
index 0000000000000000000000000000000000000000..61c94f418120908fa2900ebccef8423a8c075d43
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_ssl.py
@@ -0,0 +1,40 @@
+import os
+import platform
+import re
+import ssl
+
+import truststore
+
+# Mirrors `truststore`'s Linux fallbacks for when OpenSSL's compiled-in paths are unusable:
+# https://github.com/sethmlarson/truststore/blob/0714f72a739d182cdb8502f4e1bb4cf7ebfe4eb5/src/truststore/_openssl.py#L8-L19
+CA_FILE_CANDIDATES = [
+    "/etc/ssl/cert.pem",
+    "/etc/pki/ca-trust/extracted/pem/tls-ca-bundle.pem",
+    "/etc/pki/tls/cert.pem",
+    "/etc/ssl/certs/ca-certificates.crt",
+    "/etc/ssl/ca-bundle.pem",
+]
+
+
+# `_trust_env` is internal to `httpx2`; drop it with the Linux branch below once sethmlarson/truststore#213 ships.
+def default_ssl_context(*, _trust_env: bool = True) -> ssl.SSLContext:
+    if _trust_env and (cafile := os.environ.get("SSL_CERT_FILE")):  # pragma: no cover
+        return ssl.create_default_context(cafile=cafile)
+    if _trust_env and (capath := os.environ.get("SSL_CERT_DIR")):  # pragma: no cover
+        return ssl.create_default_context(capath=capath)
+    if platform.system() in ("Windows", "Darwin"):  # pragma: no cover
+        return truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    # `truststore` re-adds verify paths per handshake, which OpenSSL < 3.4 accumulates (sethmlarson/truststore#212).
+    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+    # Compiled-in paths, since `set_default_verify_paths()` would read `SSL_CERT_*`.
+    paths = ssl.get_default_verify_paths()
+    cafile = paths.openssl_cafile if os.path.isfile(paths.openssl_cafile) else None
+    capath = paths.openssl_capath if os.path.isdir(paths.openssl_capath) else None
+    if capath and not cafile:  # pragma: no cover
+        if not any(re.fullmatch(r"[0-9a-fA-F]{8}\.\d", f) for f in os.listdir(capath)):
+            capath = None
+    if not cafile and not capath:  # pragma: no cover
+        cafile = next(filter(os.path.isfile, CA_FILE_CANDIDATES), None)
+    if cafile or capath:
+        ctx.load_verify_locations(cafile, capath)
+    return ctx
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..0ae2720bbc2caef7d238557758295f7b1c3f9d07
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__init__.py
@@ -0,0 +1,39 @@
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .http_proxy import HTTPProxy
+from .interfaces import ConnectionInterface
+
+try:
+    from .http2 import HTTP2Connection
+except ImportError:  # pragma: no cover
+
+    class HTTP2Connection:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use http2 support, but the `h2` package is not "
+                "installed. Use 'pip install httpcore[http2]'."
+            )
+
+
+try:
+    from .socks_proxy import SOCKSProxy
+except ImportError:  # pragma: no cover
+
+    class SOCKSProxy:  # type: ignore
+        def __init__(self, *args, **kwargs) -> None:  # type: ignore
+            raise RuntimeError(
+                "Attempted to use SOCKS support, but the `socksio` package is not "
+                "installed. Use 'pip install httpcore[socks]'."
+            )
+
+
+__all__ = [
+    "HTTPConnection",
+    "ConnectionPool",
+    "HTTPProxy",
+    "HTTP11Connection",
+    "HTTP2Connection",
+    "ConnectionInterface",
+    "SOCKSProxy",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..63e616829c8297b41ad0f14b2fd6a1ec69e26f9d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3edf37739696dfcfdafcfe40500bc092691a8cae
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection_pool.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection_pool.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ca8f3546ddd3081b94776274d71060b2e2573e66
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/connection_pool.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http11.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http11.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5924f74f129b9453196bbde98f1b4c0b57e470b7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http11.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http2.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http2.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..43d9597942f175b11532ed2b2834f5c78f76dc3f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http2.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http_proxy.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http_proxy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..29a58f04c59d93f8e3f63a221153feca95179d69
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/http_proxy.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/interfaces.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/interfaces.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c55cd9470e5db42e40e968106bc88668be7e1da
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/interfaces.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/socks_proxy.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/socks_proxy.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c2a7f282e2ffff4c3978f1bfac8cfa8a745a9360
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/__pycache__/socks_proxy.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection.py
new file mode 100644
index 0000000000000000000000000000000000000000..6691a9fc09c4adac4e71e1949cf68bb0fe0eae86
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection.py
@@ -0,0 +1,208 @@
+from __future__ import annotations
+
+import itertools
+import logging
+import ssl
+import types
+import typing
+
+from .._backends.sync import SyncBackend
+from .._backends.base import SOCKET_OPTION, NetworkBackend, NetworkStream
+from .._exceptions import ConnectError, ConnectTimeout
+from .._models import Origin, Request, Response
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+RETRIES_BACKOFF_FACTOR = 0.5  # 0s, 0.5s, 1s, 2s, 4s, etc.
+
+
+logger = logging.getLogger("httpcore2.connection")
+
+
+def exponential_backoff(factor: float) -> typing.Iterator[float]:
+    """
+    Generate a geometric sequence that has a ratio of 2 and starts with 0.
+
+    For example:
+    - `factor = 2`: `0, 2, 4, 8, 16, 32, 64, ...`
+    - `factor = 3`: `0, 3, 6, 12, 24, 48, 96, ...`
+    """
+    yield 0
+    for n in itertools.count():
+        yield factor * 2**n
+
+
+class HTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        origin: Origin,
+        ssl_context: ssl.SSLContext | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: NetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        self._origin = origin
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend: NetworkBackend = SyncBackend() if network_backend is None else network_backend
+        self._connection: ConnectionInterface | None = None
+        self._connect_failed: bool = False
+        self._request_lock = Lock()
+        self._socket_options = socket_options
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        try:
+            with self._request_lock:
+                if self._connection is None:
+                    stream = self._connect(request)
+
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+                    if http2_negotiated or (self._http2 and not self._http1):
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+        except BaseException as exc:
+            self._connect_failed = True
+            raise exc
+
+        return self._connection.handle_request(request)
+
+    def _connect(self, request: Request) -> NetworkStream:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        retries_left = self._retries
+        delays = exponential_backoff(factor=RETRIES_BACKOFF_FACTOR)
+
+        while True:
+            try:
+                if self._uds is None:
+                    kwargs = {
+                        "host": self._origin.host.decode("ascii"),
+                        "port": self._origin.port,
+                        "local_address": self._local_address,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+                else:
+                    kwargs = {
+                        "path": self._uds,
+                        "timeout": timeout,
+                        "socket_options": self._socket_options,
+                    }
+                    with Trace("connect_unix_socket", logger, request, kwargs) as trace:
+                        stream = self._network_backend.connect_unix_socket(**kwargs)
+                        trace.return_value = stream
+
+                if self._origin.scheme in (b"https", b"wss"):
+                    ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                    alpn_protocols = (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                    ssl_context.set_alpn_protocols(alpn_protocols)
+
+                    kwargs = {
+                        "ssl_context": ssl_context,
+                        "server_hostname": sni_hostname or self._origin.host.decode("ascii"),
+                        "timeout": timeout,
+                    }
+                    with Trace("start_tls", logger, request, kwargs) as trace:
+                        stream = stream.start_tls(**kwargs)
+                        trace.return_value = stream
+                return stream
+            except (ConnectError, ConnectTimeout):
+                if retries_left <= 0:
+                    raise
+                retries_left -= 1
+                delay = next(delays)
+                with Trace("retry", logger, request, kwargs) as trace:
+                    self._network_backend.sleep(delay)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def close(self) -> None:
+        if self._connection is not None:
+            with Trace("close", logger, None, {}):
+                self._connection.close()
+
+    def is_connected(self) -> bool:
+        return self._connection is not None and self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        if self._connection is None:
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return self._http2 and (self._origin.scheme == b"https" or not self._http1) and not self._connect_failed
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def can_multiplex(self) -> bool:
+        return self._connection is not None and self._connection.can_multiplex()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> HTTPConnection:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self.close()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection_pool.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection_pool.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6051bacaabe3ca46e2c9a8aefac1362f159e138
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/connection_pool.py
@@ -0,0 +1,440 @@
+from __future__ import annotations
+
+import ssl
+import sys
+import types
+import typing
+from collections.abc import Generator
+
+from .._backends.sync import SyncBackend
+from .._backends.base import SOCKET_OPTION, NetworkBackend
+from .._exceptions import ConnectionNotAvailable, UnsupportedProtocol
+from .._models import Origin, Proxy, Request, Response
+from .._synchronization import Event, ShieldCancellation, ThreadLock
+from .._utils import safe_iterate
+from .connection import HTTPConnection
+from .interfaces import ConnectionInterface, RequestInterface
+
+
+class PoolRequest:
+    def __init__(self, request: Request) -> None:
+        self.request = request
+        self.connection: ConnectionInterface | None = None
+        self._connection_acquired = Event()
+
+    def assign_to_connection(self, connection: ConnectionInterface | None) -> None:
+        self.connection = connection
+        self._connection_acquired.set()
+
+    def clear_connection(self) -> None:
+        self.connection = None
+        self._connection_acquired = Event()
+
+    def wait_for_connection(self, timeout: float | None = None) -> ConnectionInterface:
+        if self.connection is None:
+            self._connection_acquired.wait(timeout=timeout)
+        assert self.connection is not None
+        return self.connection
+
+    def is_queued(self) -> bool:
+        return self.connection is None
+
+
+class ConnectionPool(RequestInterface):
+    """
+    A connection pool for making HTTP requests.
+    """
+
+    def __init__(
+        self,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy: Proxy | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: NetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish a
+                connection.
+            local_address: Local address to connect from. Can also be used to connect
+                using a particular address family. Using `local_address="0.0.0.0"`
+                will connect using an `AF_INET` address (IPv4), while using
+                `local_address="::"` will connect using an `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+            socket_options: Socket options that have to be included
+             in the TCP socket when the connection was established.
+        """
+        self._ssl_context = ssl_context
+        self._proxy = proxy
+        self._max_connections = sys.maxsize if max_connections is None else max_connections
+        self._max_keepalive_connections = (
+            sys.maxsize if max_keepalive_connections is None else max_keepalive_connections
+        )
+        self._max_keepalive_connections = min(self._max_connections, self._max_keepalive_connections)
+
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._retries = retries
+        self._local_address = local_address
+        self._uds = uds
+
+        self._network_backend = SyncBackend() if network_backend is None else network_backend
+        self._socket_options = socket_options
+
+        # The mutable state on a connection pool is the queue of incoming requests,
+        # and the set of connections that are servicing those requests.
+        self._connections: list[ConnectionInterface] = []
+        self._requests: list[PoolRequest] = []
+
+        # We only mutate the state of the connection pool within an 'optional_thread_lock'
+        # context. This holds a threading lock unless we're running in async mode,
+        # in which case it is a no-op.
+        self._optional_thread_lock = ThreadLock()
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        if self._proxy is not None:
+            if self._proxy.url.scheme in (b"socks5", b"socks5h"):
+                from .socks_proxy import Socks5Connection
+
+                return Socks5Connection(
+                    proxy_origin=self._proxy.url.origin,
+                    proxy_auth=self._proxy.auth,
+                    remote_origin=origin,
+                    ssl_context=self._ssl_context,
+                    keepalive_expiry=self._keepalive_expiry,
+                    http1=self._http1,
+                    http2=self._http2,
+                    network_backend=self._network_backend,
+                )
+            elif origin.scheme == b"http":
+                from .http_proxy import ForwardHTTPConnection
+
+                return ForwardHTTPConnection(
+                    proxy_origin=self._proxy.url.origin,
+                    proxy_headers=self._proxy.headers,
+                    proxy_ssl_context=self._proxy.ssl_context,
+                    remote_origin=origin,
+                    keepalive_expiry=self._keepalive_expiry,
+                    network_backend=self._network_backend,
+                )
+            from .http_proxy import TunnelHTTPConnection
+
+            return TunnelHTTPConnection(
+                proxy_origin=self._proxy.url.origin,
+                proxy_headers=self._proxy.headers,
+                proxy_ssl_context=self._proxy.ssl_context,
+                remote_origin=origin,
+                ssl_context=self._ssl_context,
+                keepalive_expiry=self._keepalive_expiry,
+                http1=self._http1,
+                http2=self._http2,
+                network_backend=self._network_backend,
+            )
+
+        return HTTPConnection(
+            origin=origin,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            retries=self._retries,
+            local_address=self._local_address,
+            uds=self._uds,
+            network_backend=self._network_backend,
+            socket_options=self._socket_options,
+        )
+
+    @property
+    def connections(self) -> list[ConnectionInterface]:
+        """
+        Return a list of the connections currently in the pool.
+
+        For example:
+
+        ```python
+        >>> pool.connections
+        [
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, ACTIVE, Request Count: 6]>,
+            <HTTPConnection ['https://example.com:443', HTTP/1.1, IDLE, Request Count: 9]> ,
+            <HTTPConnection ['http://example.com:80', HTTP/1.1, IDLE, Request Count: 1]>,
+        ]
+        ```
+        """
+        return list(self._connections)
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send an HTTP request, and return an HTTP response.
+
+        This is the core implementation that is called into by `.request()` or `.stream()`.
+        """
+        scheme = request.url.scheme.decode()
+        if scheme == "":
+            raise UnsupportedProtocol("Request URL is missing an 'http://' or 'https://' protocol.")
+        if scheme not in ("http", "https", "ws", "wss"):
+            raise UnsupportedProtocol(f"Request URL has an unsupported protocol '{scheme}://'.")
+
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("pool", None)
+
+        with self._optional_thread_lock:
+            # Add the incoming request to our request queue.
+            pool_request = PoolRequest(request)
+            self._requests.append(pool_request)
+
+        try:
+            while True:
+                with self._optional_thread_lock:
+                    # Assign incoming requests to available connections,
+                    # closing or creating new connections as required.
+                    closing = self._assign_requests_to_connections()
+                self._close_connections(closing)
+
+                # Wait until this request has an assigned connection.
+                connection = pool_request.wait_for_connection(timeout=timeout)
+
+                try:
+                    # Send the request on the assigned connection.
+                    response = connection.handle_request(pool_request.request)
+                except ConnectionNotAvailable:
+                    # In some cases a connection may initially be available to
+                    # handle a request, but then become unavailable.
+                    #
+                    # In this case we clear the connection and try again.
+                    pool_request.clear_connection()
+                else:
+                    break  # pragma: no cover
+
+        except BaseException as exc:
+            with self._optional_thread_lock:
+                # For any exception or cancellation we remove the request from
+                # the queue, and then re-assign requests to connections.
+                self._requests.remove(pool_request)
+                closing = self._assign_requests_to_connections()
+
+            self._close_connections(closing)
+            raise exc from None
+
+        # Return the response. Note that in this case we still have to manage
+        # the point at which the response is closed.
+        assert isinstance(response.stream, typing.Iterable)
+        return Response(
+            status=response.status,
+            headers=response.headers,
+            content=PoolByteStream(stream=response.stream, pool_request=pool_request, pool=self),
+            extensions=response.extensions,
+        )
+
+    def _assign_requests_to_connections(self) -> list[ConnectionInterface]:
+        """
+        Manage the state of the connection pool, assigning incoming
+        requests to connections as available.
+
+        Called whenever a new request is added or removed from the pool.
+
+        Any closing connections are returned, allowing the I/O for closing
+        those connections to be handled separately.
+        """
+        closing_connections: list[ConnectionInterface] = []
+        retained_connections: list[ConnectionInterface] = []
+
+        # Connections currently referenced by an in-flight request, including
+        # connections that are in the process of being established and idle
+        # connections reserved by an assigned-but-not-yet-sent request.
+        request_connections = {r.connection for r in self._requests}
+
+        # First we handle cleaning up any connections that are closed
+        # or have expired their keep-alive, in a single pass. Reserved
+        # connections skip the expiry check: they were checked when assigned,
+        # and `has_expired()` on an idle connection probes the socket.
+        for connection in self._connections:
+            reserved = connection in request_connections
+            if connection.is_closed():
+                continue
+            elif not (connection.is_connected() or reserved):
+                # Garbage: a NEW-state connection whose request was cancelled
+                # before the TCP handshake completed.  Drop it without closing
+                # (there is no socket to close yet).
+                continue
+            elif not reserved and connection.has_expired():
+                closing_connections.append(connection)
+            else:
+                retained_connections.append(connection)
+
+        # Then we close any surplus idle connections, to enforce the
+        # max_keepalive_connections setting. Reserved connections are not
+        # surplus: a request is about to be sent on them.
+        idle_surplus = (
+            sum(connection.is_idle() and connection not in request_connections for connection in retained_connections)
+            - self._max_keepalive_connections
+        )
+        if idle_surplus > 0:
+            kept: list[ConnectionInterface] = []
+            for connection in retained_connections:
+                if idle_surplus > 0 and connection.is_idle() and connection not in request_connections:
+                    closing_connections.append(connection)
+                    idle_surplus -= 1
+                else:
+                    kept.append(connection)
+            retained_connections = kept
+
+        self._connections = retained_connections
+
+        # Snapshot the set of reusable connections once, rather than rebuilding
+        # it per queued request — this is what brings the loop from O(N*M) to
+        # O(N+M) in the common case.
+        #
+        # An idle connection already assigned to an in-flight request is
+        # reserved: it stays IDLE until the winning task sends on it, so
+        # without this exclusion the next pass would assign it again and the
+        # loser would churn through `ConnectionNotAvailable`. Multiplexing
+        # connections are exempt: they can take further requests while idle.
+        available_connections = [
+            connection
+            for connection in self._connections
+            if connection.is_available()
+            and not (connection.is_idle() and connection in request_connections and not connection.can_multiplex())
+        ]
+        new_connection_budget = self._max_connections - len(self._connections)
+
+        # Assign queued requests to connections. Once no connection is
+        # available and no new connection may be created, no queued request
+        # can be assigned, so the scan stops early: this keeps a pass on a
+        # saturated pool O(connections) rather than O(in-flight requests).
+        for pool_request in self._requests:
+            if not available_connections and new_connection_budget <= 0:
+                break
+            if not pool_request.is_queued():
+                continue
+            origin = pool_request.request.url.origin
+
+            # There are three cases for how we may be able to handle the request:
+            #
+            # 1. There is an existing connection that can handle the request.
+            # 2. We can create a new connection to handle the request.
+            # 3. We can close an idle connection and then create a new connection
+            #    to handle the request.
+            for idx, connection in enumerate(available_connections):
+                if connection.can_handle_request(origin):
+                    pool_request.assign_to_connection(connection)
+                    if connection.is_idle() and not connection.can_multiplex():
+                        # An idle HTTP/1.1 connection can only take this
+                        # single request until it is released.
+                        del available_connections[idx]
+                    break
+            else:
+                if new_connection_budget > 0:
+                    connection = self.create_connection(origin)
+                    self._connections.append(connection)
+                    pool_request.assign_to_connection(connection)
+                    new_connection_budget -= 1
+                    continue
+                for idx, connection in enumerate(available_connections):
+                    if connection.is_idle():
+                        del available_connections[idx]
+                        self._connections.remove(connection)
+                        closing_connections.append(connection)
+                        connection = self.create_connection(origin)
+                        self._connections.append(connection)
+                        pool_request.assign_to_connection(connection)
+                        break
+
+        return closing_connections
+
+    def _close_connections(self, closing: list[ConnectionInterface]) -> None:
+        # Close connections which have been removed from the pool.
+        with ShieldCancellation():
+            for connection in closing:
+                connection.close()
+
+    def close(self) -> None:
+        # Explicitly close the connection pool.
+        # Clears all existing requests and connections.
+        with self._optional_thread_lock:
+            closing_connections = list(self._connections)
+            self._connections = []
+        self._close_connections(closing_connections)
+
+    def __enter__(self) -> ConnectionPool:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        with self._optional_thread_lock:
+            request_is_queued = [request.is_queued() for request in self._requests]
+            connection_is_idle = [connection.is_idle() for connection in self._connections]
+
+            num_active_requests = request_is_queued.count(False)
+            num_queued_requests = request_is_queued.count(True)
+            num_active_connections = connection_is_idle.count(False)
+            num_idle_connections = connection_is_idle.count(True)
+
+        requests_info = f"Requests: {num_active_requests} active, {num_queued_requests} queued"
+        connection_info = f"Connections: {num_active_connections} active, {num_idle_connections} idle"
+
+        return f"<{class_name} [{requests_info} | {connection_info}]>"
+
+
+class PoolByteStream:
+    def __init__(
+        self,
+        stream: typing.Iterable[bytes],
+        pool_request: PoolRequest,
+        pool: ConnectionPool,
+    ) -> None:
+        self._stream = stream
+        self._pool_request = pool_request
+        self._pool = pool
+        self._closed = False
+
+    def __iter__(self) -> Generator[bytes]:
+        with safe_iterate(self._stream) as iterator:
+            for chunk in iterator:
+                yield chunk
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with ShieldCancellation():
+                if hasattr(self._stream, "close"):
+                    self._stream.close()
+
+            with self._pool._optional_thread_lock:
+                self._pool._requests.remove(self._pool_request)
+                closing = self._pool._assign_requests_to_connections()
+
+            self._pool._close_connections(closing)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http11.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http11.py
new file mode 100644
index 0000000000000000000000000000000000000000..50bce83373d3f65a10e214874669521a48c63e17
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http11.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import enum
+import logging
+import ssl
+import time
+import types
+import typing
+from collections.abc import Generator
+
+import h11
+
+from .._backends.base import NetworkStream
+from .._exceptions import (
+    ConnectionNotAvailable,
+    LocalProtocolError,
+    RemoteProtocolError,
+    WriteError,
+    map_exceptions,
+)
+from .._models import Origin, Request, Response
+from .._synchronization import Lock, ShieldCancellation
+from .._trace import Trace
+from .._utils import safe_iterate
+from .interfaces import ConnectionInterface
+
+logger = logging.getLogger("httpcore2.http11")
+
+
+# A subset of `h11.Event` types supported by `_send_event`
+H11SendEvent = h11.Request | h11.Data | h11.EndOfMessage
+
+
+class HTTPConnectionState(enum.IntEnum):
+    NEW = 0
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class HTTP11Connection(ConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    MAX_INCOMPLETE_EVENT_SIZE = 100 * 1024
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: float | None = None,
+    ) -> None:
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: float | None = keepalive_expiry
+        self._expire_at: float | None = None
+        self._state = HTTPConnectionState.NEW
+        self._state_lock = Lock()
+        self._request_count = 0
+        self._h11_state = h11.Connection(
+            our_role=h11.CLIENT,
+            max_incomplete_event_size=self.MAX_INCOMPLETE_EVENT_SIZE,
+        )
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.NEW, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._state = HTTPConnectionState.ACTIVE
+                self._expire_at = None
+            else:
+                raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request}
+            try:
+                with Trace("send_request_headers", logger, request, kwargs) as trace:
+                    self._send_request_headers(**kwargs)
+                with Trace("send_request_body", logger, request, kwargs) as trace:
+                    self._send_request_body(**kwargs)
+            except WriteError:
+                # If we get a write error while we're writing the request,
+                # then we suppress this error and move on to attempting to
+                # read the response. Servers can sometimes close the request
+                # preemptively and then respond with a well formed HTTP
+                # error response.
+                pass
+
+            with Trace("receive_response_headers", logger, request, kwargs) as trace:
+                (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                    trailing_data,
+                ) = self._receive_response_headers(**kwargs)
+                trace.return_value = (
+                    http_version,
+                    status,
+                    reason_phrase,
+                    headers,
+                )
+
+            network_stream = self._network_stream
+
+            # CONNECT or Upgrade request
+            if (status == 101) or ((request.method == b"CONNECT") and (200 <= status < 300)):
+                network_stream = HTTP11UpgradeStream(network_stream, trailing_data)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP11ConnectionByteStream(self, request),
+                extensions={
+                    "http_version": http_version,
+                    "reason_phrase": reason_phrase,
+                    "network_stream": network_stream,
+                },
+            )
+        except BaseException as exc:
+            with ShieldCancellation():
+                with Trace("response_closed", logger, request) as trace:
+                    self._response_closed()
+            raise exc
+
+    # Sending the request...
+
+    def _send_request_headers(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with map_exceptions({h11.LocalProtocolError: LocalProtocolError}):
+            event = h11.Request(
+                method=request.method,
+                target=request.url.target,
+                headers=request.headers,
+            )
+        self._send_event(event, timeout=timeout)
+
+    def _send_request_body(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        assert isinstance(request.stream, typing.Iterable)
+        with safe_iterate(request.stream) as iterator:
+            for chunk in iterator:
+                event = h11.Data(data=chunk)
+                self._send_event(event, timeout=timeout)
+
+        self._send_event(h11.EndOfMessage(), timeout=timeout)
+
+    def _send_event(self, event: h11.Event, timeout: float | None = None) -> None:
+        bytes_to_send = self._h11_state.send(event)
+        if bytes_to_send is not None:
+            self._network_stream.write(bytes_to_send, timeout=timeout)
+
+    # Receiving the response...
+
+    def _receive_response_headers(
+        self, request: Request
+    ) -> tuple[bytes, int, bytes, list[tuple[bytes, bytes]], bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Response):
+                break
+            if isinstance(event, h11.InformationalResponse) and event.status_code == 101:
+                break
+
+        http_version = b"HTTP/" + event.http_version
+
+        # h11 version 0.11+ supports a `raw_items` interface to get the
+        # raw header casing, rather than the enforced lowercase headers.
+        headers = event.headers.raw_items()
+
+        trailing_data, _ = self._h11_state.trailing_data
+
+        return http_version, event.status_code, event.reason, headers, trailing_data
+
+    def _receive_response_body(self, request: Request) -> Generator[bytes]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        while True:
+            event = self._receive_event(timeout=timeout)
+            if isinstance(event, h11.Data):
+                yield bytes(event.data)
+            elif isinstance(event, (h11.EndOfMessage, h11.PAUSED)):
+                break
+
+    def _receive_event(self, timeout: float | None = None) -> h11.Event | type[h11.PAUSED]:
+        while True:
+            with map_exceptions({h11.RemoteProtocolError: RemoteProtocolError}):
+                event = self._h11_state.next_event()
+
+            if event is h11.NEED_DATA:
+                data = self._network_stream.read(self.READ_NUM_BYTES, timeout=timeout)
+
+                # If we feed this case through h11 we'll raise an exception like:
+                #
+                #     httpcore2.RemoteProtocolError: can't handle event type
+                #     ConnectionClosed when role=SERVER and state=SEND_RESPONSE
+                #
+                # Which is accurate, but not very informative from an end-user
+                # perspective. Instead we handle this case distinctly and treat
+                # it as a ConnectError.
+                if data == b"" and self._h11_state.their_state == h11.SEND_RESPONSE:
+                    msg = "Server disconnected without sending a response."
+                    raise RemoteProtocolError(msg)
+
+                self._h11_state.receive_data(data)
+            else:
+                # mypy fails to narrow the type in the above if statement above
+                return event  # type: ignore[return-value]
+
+    def _response_closed(self) -> None:
+        with self._state_lock:
+            if self._h11_state.our_state is h11.DONE and self._h11_state.their_state is h11.DONE:
+                self._state = HTTPConnectionState.IDLE
+                self._h11_state.start_next_cycle()
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+            else:
+                self.close()
+
+    # Once the connection is no longer required...
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # The ConnectionInterface methods provide information about the state of
+    # the connection, allowing for a connection pooling implementation to
+    # determine when to reuse and when to close the connection...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_connected(self) -> bool:
+        return not self.is_closed()
+
+    def is_available(self) -> bool:
+        # Note that HTTP/1.1 connections in the "NEW" state are not treated as
+        # being "available". The control flow which created the connection will
+        # be able to send an outgoing request, but the connection will not be
+        # acquired from the connection pool for any other request.
+        return self._state == HTTPConnectionState.IDLE
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        # Read `_expire_at` once into a local: on free-threaded builds another
+        # thread may reset it to `None` between the check and the comparison.
+        expire_at = self._expire_at
+        keepalive_expired = expire_at is not None and now > expire_at
+
+        # If the HTTP connection is idle but the socket is readable, then the
+        # only valid state is that the socket is about to return b"", indicating
+        # a server-initiated disconnect.
+        server_disconnected = self._state == HTTPConnectionState.IDLE and self._network_stream.get_extra_info(
+            "is_readable"
+        )
+
+        return keepalive_expired or server_disconnected
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return f"{origin!r}, HTTP/1.1, {self._state.name}, Request Count: {self._request_count}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return f"<{class_name} [{origin!r}, {self._state.name}, Request Count: {self._request_count}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> HTTP11Connection:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP11ConnectionByteStream:
+    def __init__(self, connection: HTTP11Connection, request: Request) -> None:
+        self._connection = connection
+        self._request = request
+        self._closed = False
+
+    def __iter__(self) -> Generator[bytes]:
+        kwargs = {"request": self._request}
+        try:
+            with Trace("receive_response_body", logger, self._request, kwargs):
+                with safe_iterate(self._connection._receive_response_body(**kwargs)) as iterator:
+                    for chunk in iterator:
+                        yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with ShieldCancellation():
+                self.close()
+            raise exc
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            with Trace("response_closed", logger, self._request):
+                self._connection._response_closed()
+
+
+class HTTP11UpgradeStream(NetworkStream):
+    def __init__(self, stream: NetworkStream, leading_data: bytes) -> None:
+        self._stream = stream
+        self._leading_data = leading_data
+
+    def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        if self._leading_data:
+            buffer = self._leading_data[:max_bytes]
+            self._leading_data = self._leading_data[max_bytes:]
+            return buffer
+        else:
+            return self._stream.read(max_bytes, timeout)
+
+    def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        self._stream.write(buffer, timeout)
+
+    def close(self) -> None:
+        self._stream.close()
+
+    def start_tls(
+        self,
+        ssl_context: ssl.SSLContext,
+        server_hostname: str | None = None,
+        timeout: float | None = None,
+    ) -> NetworkStream:
+        return self._stream.start_tls(ssl_context, server_hostname, timeout)
+
+    def get_extra_info(self, info: str) -> typing.Any:
+        return self._stream.get_extra_info(info)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http2.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http2.py
new file mode 100644
index 0000000000000000000000000000000000000000..d4fca1e87c78fd45ff5d570a614574cfa3bb97b8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http2.py
@@ -0,0 +1,582 @@
+from __future__ import annotations
+
+import enum
+import logging
+import time
+import types
+import typing
+from collections.abc import Generator
+
+import h2.config
+import h2.connection
+import h2.events
+import h2.exceptions
+import h2.settings
+
+from .._backends.base import NetworkStream
+from .._exceptions import ConnectionNotAvailable, LocalProtocolError, RemoteProtocolError
+from .._models import Origin, Request, Response
+from .._synchronization import Lock, Semaphore, ShieldCancellation
+from .._trace import Trace
+from .._utils import safe_iterate
+from .interfaces import ConnectionInterface
+
+logger = logging.getLogger("httpcore2.http2")
+
+
+def has_body_headers(request: Request) -> bool:
+    return any(k.lower() == b"content-length" or k.lower() == b"transfer-encoding" for k, _v in request.headers)
+
+
+class HTTPConnectionState(enum.IntEnum):
+    ACTIVE = 1
+    IDLE = 2
+    CLOSED = 3
+
+
+class HTTP2Connection(ConnectionInterface):
+    READ_NUM_BYTES = 64 * 1024
+    CONFIG = h2.config.H2Configuration(validate_inbound_headers=False)
+
+    def __init__(
+        self,
+        origin: Origin,
+        stream: NetworkStream,
+        keepalive_expiry: float | None = None,
+    ):
+        self._origin = origin
+        self._network_stream = stream
+        self._keepalive_expiry: float | None = keepalive_expiry
+        self._h2_state = h2.connection.H2Connection(config=self.CONFIG)
+        self._state = HTTPConnectionState.IDLE
+        self._expire_at: float | None = None
+        self._request_count = 0
+        self._init_lock = Lock()
+        self._state_lock = Lock()
+        self._read_lock = Lock()
+        self._write_lock = Lock()
+        self._sent_connection_init = False
+        self._used_all_stream_ids = False
+        self._connection_error = False
+
+        # Mapping from stream ID to response stream events.
+        self._events: dict[
+            int,
+            list[h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded | h2.events.StreamReset,],
+        ] = {}
+
+        # Connection terminated events are stored as state since
+        # we need to handle them for all streams.
+        self._connection_terminated: h2.events.ConnectionTerminated | None = None
+
+        self._read_exception: Exception | None = None
+        self._write_exception: Exception | None = None
+
+    def handle_request(self, request: Request) -> Response:
+        if not self.can_handle_request(request.url.origin):
+            # This cannot occur in normal operation, since the connection pool
+            # will only send requests on connections that handle them.
+            # It's in place simply for resilience as a guard against incorrect
+            # usage, for anyone working directly with httpcore connections.
+            raise RuntimeError(f"Attempted to send request to {request.url.origin} on connection to {self._origin}")
+
+        with self._state_lock:
+            if self._state in (HTTPConnectionState.ACTIVE, HTTPConnectionState.IDLE):
+                self._request_count += 1
+                self._expire_at = None
+                self._state = HTTPConnectionState.ACTIVE
+            else:
+                raise ConnectionNotAvailable()
+
+        with self._init_lock:
+            if not self._sent_connection_init:
+                try:
+                    sci_kwargs = {"request": request}
+                    with Trace("send_connection_init", logger, request, sci_kwargs):
+                        self._send_connection_init(**sci_kwargs)
+                except BaseException as exc:
+                    with ShieldCancellation():
+                        self.close()
+                    raise exc
+
+                self._sent_connection_init = True
+
+                # Initially start with just 1 until the remote server provides
+                # its max_concurrent_streams value
+                self._max_streams = 1
+
+                # Revoked permits still held by active or queued requests.
+                self._max_streams_deficit = 0
+
+                local_settings_max_streams = self._h2_state.local_settings.max_concurrent_streams
+                self._max_streams_semaphore = Semaphore(local_settings_max_streams)
+
+                for _ in range(local_settings_max_streams - self._max_streams):
+                    self._max_streams_semaphore.acquire()
+
+        # A queued request may receive a permit just before the limit drops.
+        while True:
+            self._max_streams_semaphore.acquire()
+            with ShieldCancellation():
+                with self._state_lock:
+                    if not self._max_streams_deficit:
+                        break
+                    self._max_streams_deficit -= 1
+
+        try:
+            stream_id = self._h2_state.get_next_available_stream_id()
+            self._events[stream_id] = []
+        except h2.exceptions.NoAvailableStreamIDError:  # pragma: no cover
+            self._used_all_stream_ids = True
+            self._request_count -= 1
+            self._max_streams_semaphore.release()
+            raise ConnectionNotAvailable()
+
+        try:
+            kwargs = {"request": request, "stream_id": stream_id}
+            with Trace("send_request_headers", logger, request, kwargs):
+                self._send_request_headers(request=request, stream_id=stream_id)
+            with Trace("send_request_body", logger, request, kwargs):
+                self._send_request_body(request=request, stream_id=stream_id)
+            with Trace("receive_response_headers", logger, request, kwargs) as trace:
+                status, headers = self._receive_response(request=request, stream_id=stream_id)
+                trace.return_value = (status, headers)
+
+            return Response(
+                status=status,
+                headers=headers,
+                content=HTTP2ConnectionByteStream(self, request, stream_id=stream_id),
+                extensions={
+                    "http_version": b"HTTP/2",
+                    "network_stream": self._network_stream,
+                    "stream_id": stream_id,
+                },
+            )
+        except BaseException as exc:  # noqa: PIE786
+            with ShieldCancellation():
+                kwargs = {"stream_id": stream_id}
+                with Trace("response_closed", logger, request, kwargs):
+                    self._response_closed(stream_id=stream_id)
+
+            if isinstance(exc, h2.exceptions.ProtocolError):
+                # One case where h2 can raise a protocol error is when a
+                # closed frame has been seen by the state machine.
+                #
+                # This happens when one stream is reading, and encounters
+                # a GOAWAY event. Other flows of control may then raise
+                # a protocol error at any point they interact with the 'h2_state'.
+                #
+                # In this case we'll have stored the event, and should raise
+                # it as a RemoteProtocolError.
+                if self._connection_terminated:  # pragma: no cover
+                    raise RemoteProtocolError(self._connection_terminated)
+                # If h2 raises a protocol error in some other state then we
+                # must somehow have made a protocol violation.
+                raise LocalProtocolError(exc)  # pragma: no cover
+
+            raise exc
+
+    def _send_connection_init(self, request: Request) -> None:
+        """
+        The HTTP/2 connection requires some initial setup before we can start
+        using individual request/response streams on it.
+        """
+        # Need to set these manually here instead of manipulating via
+        # __setitem__() otherwise the H2Connection will emit SettingsUpdate
+        # frames in addition to sending the undesired defaults.
+        self._h2_state.local_settings = h2.settings.Settings(
+            client=True,
+            initial_values={
+                # Disable PUSH_PROMISE frames from the server since we don't do anything
+                # with them for now.  Maybe when we support caching?
+                h2.settings.SettingCodes.ENABLE_PUSH: 0,
+                # These two are taken from h2 for safe defaults
+                h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS: 100,
+                h2.settings.SettingCodes.MAX_HEADER_LIST_SIZE: 65536,
+            },
+        )
+
+        # Some websites (*cough* Yahoo *cough*) balk at this setting being
+        # present in the initial handshake since it's not defined in the original
+        # RFC despite the RFC mandating ignoring settings you don't know about.
+        del self._h2_state.local_settings[h2.settings.SettingCodes.ENABLE_CONNECT_PROTOCOL]
+
+        self._h2_state.initiate_connection()
+        self._h2_state.increment_flow_control_window(2**24)
+        self._write_outgoing_data(request)
+
+    # Sending the request...
+
+    def _send_request_headers(self, request: Request, stream_id: int) -> None:
+        """
+        Send the request headers to a given stream ID.
+        """
+        end_stream = not has_body_headers(request)
+
+        # In HTTP/2 the ':authority' pseudo-header is used instead of 'Host'.
+        # In order to gracefully handle HTTP/1.1 and HTTP/2 we always require
+        # HTTP/1.1 style headers, and map them appropriately if we end up on
+        # an HTTP/2 connection.
+        authority = [v for k, v in request.headers if k.lower() == b"host"][0]
+
+        headers = [
+            (b":method", request.method),
+            (b":authority", authority),
+            (b":scheme", request.url.scheme),
+            (b":path", request.url.target),
+        ] + [
+            (k.lower(), v)
+            for k, v in request.headers
+            if k.lower()
+            not in (
+                b"host",
+                b"transfer-encoding",
+            )
+        ]
+
+        self._h2_state.send_headers(stream_id, headers, end_stream=end_stream)
+        self._h2_state.increment_flow_control_window(2**24, stream_id=stream_id)
+        self._write_outgoing_data(request)
+
+    def _send_request_body(self, request: Request, stream_id: int) -> None:
+        """
+        Iterate over the request body sending it to a given stream ID.
+        """
+        if not has_body_headers(request):
+            return
+
+        assert isinstance(request.stream, typing.Iterable)
+        with safe_iterate(request.stream) as iterator:
+            for chunk in iterator:
+                self._send_stream_data(request, stream_id, chunk)
+
+        self._send_end_stream(request, stream_id)
+
+    def _send_stream_data(self, request: Request, stream_id: int, data: bytes) -> None:
+        """
+        Send a single chunk of data in one or more data frames.
+        """
+        position = 0
+        while position < len(data):
+            max_flow = self._wait_for_outgoing_flow(request, stream_id)
+            chunk = data[position : position + max_flow]
+            position += len(chunk)
+            self._h2_state.send_data(stream_id, chunk)
+            self._write_outgoing_data(request)
+
+    def _send_end_stream(self, request: Request, stream_id: int) -> None:
+        """
+        Send an empty data frame on on a given stream ID with the END_STREAM flag set.
+        """
+        self._h2_state.end_stream(stream_id)
+        self._write_outgoing_data(request)
+
+    # Receiving the response...
+
+    def _receive_response(self, request: Request, stream_id: int) -> tuple[int, list[tuple[bytes, bytes]]]:
+        """
+        Return the response status code and headers for a given stream ID.
+        """
+        while True:
+            event = self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.ResponseReceived):
+                break
+
+        status_code = 200
+        headers: list[tuple[bytes, bytes]] = []
+        assert event.headers is not None
+        for k, v in event.headers:
+            if k == b":status":
+                status_code = int(v.decode("ascii", errors="ignore"))
+            elif not k.startswith(b":"):
+                headers.append((k, v))
+
+        return (status_code, headers)
+
+    def _receive_response_body(self, request: Request, stream_id: int) -> Generator[bytes]:
+        """
+        Iterator that returns the bytes of the response body for a given stream ID.
+        """
+        while True:
+            event = self._receive_stream_event(request, stream_id)
+            if isinstance(event, h2.events.DataReceived):
+                assert event.flow_controlled_length is not None
+                assert event.data is not None
+                amount = event.flow_controlled_length
+                self._h2_state.acknowledge_received_data(amount, stream_id)
+                self._write_outgoing_data(request)
+                yield event.data
+            elif isinstance(event, h2.events.StreamEnded):
+                break
+
+    def _receive_stream_event(
+        self, request: Request, stream_id: int
+    ) -> h2.events.ResponseReceived | h2.events.DataReceived | h2.events.StreamEnded:
+        """
+        Return the next available event for a given stream ID.
+
+        Will read more data from the network if required.
+        """
+        while not self._events.get(stream_id):
+            self._receive_events(request, stream_id)
+        event = self._events[stream_id].pop(0)
+        if isinstance(event, h2.events.StreamReset):
+            raise RemoteProtocolError(event)
+        return event
+
+    def _receive_events(self, request: Request, stream_id: int | None = None) -> None:
+        """
+        Read some data from the network until we see one or more events
+        for a given stream ID.
+        """
+        with self._read_lock:
+            if self._connection_terminated is not None:
+                last_stream_id = self._connection_terminated.last_stream_id
+                if stream_id and last_stream_id and stream_id > last_stream_id:
+                    self._request_count -= 1
+                    raise ConnectionNotAvailable()
+                raise RemoteProtocolError(self._connection_terminated)
+
+            # This conditional is a bit icky. We don't want to block reading if we've
+            # actually got an event to return for a given stream. We need to do that
+            # check *within* the atomic read lock. Though it also need to be optional,
+            # because when we call it from `_wait_for_outgoing_flow` we *do* want to
+            # block until we've available flow control, event when we have events
+            # pending for the stream ID we're attempting to send on.
+            if stream_id is None or not self._events.get(stream_id):
+                events = self._read_incoming_data(request)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        with Trace("receive_remote_settings", logger, request) as trace:
+                            trace.return_value = event
+
+                    elif isinstance(
+                        event,
+                        (
+                            h2.events.ResponseReceived,
+                            h2.events.DataReceived,
+                            h2.events.StreamEnded,
+                            h2.events.StreamReset,
+                        ),
+                    ):
+                        if event.stream_id in self._events:
+                            self._events[event.stream_id].append(event)
+
+                    elif isinstance(event, h2.events.ConnectionTerminated):
+                        self._connection_terminated = event
+
+        self._write_outgoing_data(request)
+
+    def _receive_remote_settings_change(self, event: h2.events.RemoteSettingsChanged) -> None:
+        max_concurrent_streams = event.changed_settings.get(h2.settings.SettingCodes.MAX_CONCURRENT_STREAMS)
+        if max_concurrent_streams:
+            new_max_streams = min(
+                max_concurrent_streams.new_value,
+                self._h2_state.local_settings.max_concurrent_streams,
+            )
+            if new_max_streams and new_max_streams != self._max_streams:
+                # Never wait for permits while holding the read lock.
+                while new_max_streams > self._max_streams:
+                    if self._max_streams_deficit > 0:
+                        self._max_streams_deficit -= 1
+                    else:
+                        self._max_streams_semaphore.release()
+                    self._max_streams += 1
+                while new_max_streams < self._max_streams:
+                    if not self._max_streams_semaphore.acquire_if_available():
+                        self._max_streams_deficit += 1
+                    self._max_streams -= 1
+
+    def _response_closed(self, stream_id: int) -> None:
+        with self._state_lock:
+            if stream_id in self._events:
+                if self._max_streams_deficit > 0:
+                    self._max_streams_deficit -= 1
+                else:
+                    self._max_streams_semaphore.release()
+                del self._events[stream_id]
+            if self._connection_terminated and not self._events:
+                self.close()
+
+            elif self._state == HTTPConnectionState.ACTIVE and not self._events:
+                self._state = HTTPConnectionState.IDLE
+                if self._keepalive_expiry is not None:
+                    now = time.monotonic()
+                    self._expire_at = now + self._keepalive_expiry
+                if self._used_all_stream_ids:  # pragma: no cover
+                    self.close()
+
+    def close(self) -> None:
+        # Note that this method unilaterally closes the connection, and does
+        # not have any kind of locking in place around it.
+        self._h2_state.close_connection()
+        self._state = HTTPConnectionState.CLOSED
+        self._network_stream.close()
+
+    # Wrappers around network read/write operations...
+
+    def _read_incoming_data(self, request: Request) -> list[h2.events.Event]:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("read", None)
+
+        if self._read_exception is not None:
+            raise self._read_exception  # pragma: no cover
+
+        try:
+            data = self._network_stream.read(self.READ_NUM_BYTES, timeout)
+            if data == b"":
+                raise RemoteProtocolError("Server disconnected")
+        except Exception as exc:
+            # If we get a network error we should:
+            #
+            # 1. Save the exception and just raise it immediately on any future reads.
+            #    (For example, this means that a single read timeout or disconnect will
+            #    immediately close all pending streams. Without requiring multiple
+            #    sequential timeouts.)
+            # 2. Mark the connection as errored, so that we don't accept any other
+            #    incoming requests.
+            self._read_exception = exc
+            self._connection_error = True
+            raise exc
+
+        # Apply settings and stream admission limits atomically.
+        with ShieldCancellation():
+            with self._state_lock:
+                events: list[h2.events.Event] = self._h2_state.receive_data(data)
+                for event in events:
+                    if isinstance(event, h2.events.RemoteSettingsChanged):
+                        self._receive_remote_settings_change(event)
+
+        return events
+
+    def _write_outgoing_data(self, request: Request) -> None:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("write", None)
+
+        with self._write_lock:
+            data_to_send = self._h2_state.data_to_send()
+
+            if self._write_exception is not None:
+                raise self._write_exception  # pragma: no cover
+
+            try:
+                self._network_stream.write(data_to_send, timeout)
+            except Exception as exc:  # pragma: no cover
+                # If we get a network error we should:
+                #
+                # 1. Save the exception and just raise it immediately on any future write.
+                #    (For example, this means that a single write timeout or disconnect will
+                #    immediately close all pending streams. Without requiring multiple
+                #    sequential timeouts.)
+                # 2. Mark the connection as errored, so that we don't accept any other
+                #    incoming requests.
+                self._write_exception = exc
+                self._connection_error = True
+                raise exc
+
+    # Flow control...
+
+    def _wait_for_outgoing_flow(self, request: Request, stream_id: int) -> int:
+        """
+        Returns the maximum allowable outgoing flow for a given stream.
+
+        If the allowable flow is zero, then waits on the network until
+        WindowUpdated frames have increased the flow rate.
+        https://tools.ietf.org/html/rfc7540#section-6.9
+        """
+        local_flow: int = self._h2_state.local_flow_control_window(stream_id)
+        max_frame_size: int = self._h2_state.max_outbound_frame_size
+        flow = min(local_flow, max_frame_size)
+        while flow <= 0:
+            self._receive_events(request)
+            local_flow = self._h2_state.local_flow_control_window(stream_id)
+            max_frame_size = self._h2_state.max_outbound_frame_size
+            flow = min(local_flow, max_frame_size)
+        return flow
+
+    # Interface for connection pooling...
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._origin
+
+    def is_connected(self) -> bool:
+        return not self.is_closed()
+
+    def is_available(self) -> bool:
+        return (
+            self._state != HTTPConnectionState.CLOSED
+            and not self._connection_error
+            and not self._used_all_stream_ids
+            and not (self._h2_state.state_machine.state == h2.connection.ConnectionState.CLOSED)
+        )
+
+    def has_expired(self) -> bool:
+        now = time.monotonic()
+        # Read `_expire_at` once into a local: on free-threaded builds another
+        # thread may reset it to `None` between the check and the comparison.
+        expire_at = self._expire_at
+        return expire_at is not None and now > expire_at
+
+    def is_idle(self) -> bool:
+        return self._state == HTTPConnectionState.IDLE
+
+    def can_multiplex(self) -> bool:
+        return True
+
+    def is_closed(self) -> bool:
+        return self._state == HTTPConnectionState.CLOSED
+
+    def info(self) -> str:
+        origin = str(self._origin)
+        return f"{origin!r}, HTTP/2, {self._state.name}, Request Count: {self._request_count}"
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        origin = str(self._origin)
+        return f"<{class_name} [{origin!r}, {self._state.name}, Request Count: {self._request_count}]>"
+
+    # These context managers are not used in the standard flow, but are
+    # useful for testing or working with connection instances directly.
+
+    def __enter__(self) -> HTTP2Connection:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+
+class HTTP2ConnectionByteStream:
+    def __init__(self, connection: HTTP2Connection, request: Request, stream_id: int) -> None:
+        self._connection = connection
+        self._request = request
+        self._stream_id = stream_id
+        self._closed = False
+
+    def __iter__(self) -> Generator[bytes]:
+        kwargs = {"request": self._request, "stream_id": self._stream_id}
+        try:
+            with Trace("receive_response_body", logger, self._request, kwargs):
+                with safe_iterate(
+                    self._connection._receive_response_body(request=self._request, stream_id=self._stream_id)
+                ) as iterator:
+                    for chunk in iterator:
+                        yield chunk
+        except BaseException as exc:
+            # If we get an exception while streaming the response,
+            # we want to close the response (and possibly the connection)
+            # before raising that exception.
+            with ShieldCancellation():
+                self.close()
+            raise exc
+
+    def close(self) -> None:
+        if not self._closed:
+            self._closed = True
+            kwargs = {"stream_id": self._stream_id}
+            with Trace("response_closed", logger, self._request, kwargs):
+                self._connection._response_closed(stream_id=self._stream_id)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http_proxy.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http_proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..bde07ce00296025c41e42ced5fcfbe507efe5b0a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/http_proxy.py
@@ -0,0 +1,357 @@
+from __future__ import annotations
+
+import base64
+import logging
+import ssl
+import typing
+
+from .._backends.base import SOCKET_OPTION, NetworkBackend
+from .._exceptions import ProxyError
+from .._models import (
+    URL,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+)
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .connection import HTTPConnection
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+ByteOrStr = bytes | str
+HeadersAsSequence = typing.Sequence[tuple[ByteOrStr, ByteOrStr]]
+HeadersAsMapping = typing.Mapping[ByteOrStr, ByteOrStr]
+
+
+logger = logging.getLogger("httpcore2.proxy")
+
+
+def merge_headers(
+    default_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+    override_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+) -> list[tuple[bytes, bytes]]:
+    """
+    Append default_headers and override_headers, de-duplicating if a key exists
+    in both cases.
+    """
+    default_headers = [] if default_headers is None else list(default_headers)
+    override_headers = [] if override_headers is None else list(override_headers)
+    has_override = set(key.lower() for key, _value in override_headers)
+    default_headers = [(key, value) for key, value in default_headers if key.lower() not in has_override]
+    return default_headers + override_headers
+
+
+class HTTPProxy(ConnectionPool):  # pragma: no cover
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: URL | bytes | str,
+        proxy_auth: tuple[bytes | str, bytes | str] | None = None,
+        proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        local_address: str | None = None,
+        uds: str | None = None,
+        network_backend: NetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            proxy_auth: Any proxy authentication as a two-tuple of
+                (username, password). May be either bytes or ascii-only str.
+            proxy_headers: Any HTTP headers to use for the proxy requests.
+                For example `{"Proxy-Authorization": "Basic <username>:<password>"}`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            proxy_ssl_context: The same as `ssl_context`, but for a proxy server rather than a remote origin.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+            local_address=local_address,
+            uds=uds,
+            socket_options=socket_options,
+        )
+
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if self._proxy_url.scheme == b"http" and proxy_ssl_context is not None:  # pragma: no cover
+            raise RuntimeError("The `proxy_ssl_context` argument is not allowed for the http scheme")
+
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        if proxy_auth is not None:
+            username = enforce_bytes(proxy_auth[0], name="proxy_auth")
+            password = enforce_bytes(proxy_auth[1], name="proxy_auth")
+            userpass = username + b":" + password
+            authorization = b"Basic " + base64.b64encode(userpass)
+            self._proxy_headers = [(b"Proxy-Authorization", authorization)] + self._proxy_headers
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        if origin.scheme == b"http":
+            return ForwardHTTPConnection(
+                proxy_origin=self._proxy_url.origin,
+                proxy_headers=self._proxy_headers,
+                remote_origin=origin,
+                keepalive_expiry=self._keepalive_expiry,
+                network_backend=self._network_backend,
+                proxy_ssl_context=self._proxy_ssl_context,
+            )
+        return TunnelHTTPConnection(
+            proxy_origin=self._proxy_url.origin,
+            proxy_headers=self._proxy_headers,
+            remote_origin=origin,
+            ssl_context=self._ssl_context,
+            proxy_ssl_context=self._proxy_ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class ForwardHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_headers: HeadersAsMapping | HeadersAsSequence | None = None,
+        keepalive_expiry: float | None = None,
+        network_backend: NetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+    ) -> None:
+        self._connection = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._remote_origin = remote_origin
+
+    def handle_request(self, request: Request) -> Response:
+        headers = merge_headers(self._proxy_headers, request.headers)
+        url = URL(
+            scheme=self._proxy_origin.scheme,
+            host=self._proxy_origin.host,
+            port=self._proxy_origin.port,
+            target=bytes(request.url) if request.url.target.startswith(b"/") else request.url.target,
+        )
+        proxy_request = Request(
+            method=request.method,
+            url=url,
+            headers=headers,
+            content=request.stream,
+            extensions={
+                key: value for key, value in request.extensions.items() if key not in ("sni_hostname", "target")
+            },
+        )
+        return self._connection.handle_request(proxy_request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_connected(self) -> bool:
+        return self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
+
+
+class TunnelHTTPConnection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        ssl_context: ssl.SSLContext | None = None,
+        proxy_ssl_context: ssl.SSLContext | None = None,
+        proxy_headers: typing.Sequence[tuple[bytes, bytes]] | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: NetworkBackend | None = None,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        self._connection: ConnectionInterface = HTTPConnection(
+            origin=proxy_origin,
+            keepalive_expiry=keepalive_expiry,
+            network_backend=network_backend,
+            socket_options=socket_options,
+            ssl_context=proxy_ssl_context,
+        )
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._ssl_context = ssl_context
+        self._proxy_ssl_context = proxy_ssl_context
+        self._proxy_headers = enforce_headers(proxy_headers, name="proxy_headers")
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+        self._connect_lock = Lock()
+        self._connected = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if not self._connected:
+                target = b"%b:%d" % (self._remote_origin.host, self._remote_origin.port)
+
+                connect_url = URL(
+                    scheme=self._proxy_origin.scheme,
+                    host=self._proxy_origin.host,
+                    port=self._proxy_origin.port,
+                    target=target,
+                )
+                connect_headers = merge_headers([(b"Host", target), (b"Accept", b"*/*")], self._proxy_headers)
+                connect_request = Request(
+                    method=b"CONNECT",
+                    url=connect_url,
+                    headers=connect_headers,
+                    extensions={
+                        key: value for key, value in request.extensions.items() if key not in ("sni_hostname", "target")
+                    },
+                )
+                connect_response = self._connection.handle_request(connect_request)
+
+                if connect_response.status < 200 or connect_response.status > 299:
+                    reason_bytes = connect_response.extensions.get("reason_phrase", b"")
+                    reason_str = reason_bytes.decode("ascii", errors="ignore")
+                    msg = f"{connect_response.status} {reason_str}"
+                    self._connection.close()
+                    raise ProxyError(msg)
+
+                stream = connect_response.extensions["network_stream"]
+
+                # Upgrade the stream to SSL
+                ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                alpn_protocols = (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                ssl_context.set_alpn_protocols(alpn_protocols)
+
+                server_hostname = request.extensions.get("sni_hostname") or self._remote_origin.host.decode("ascii")
+                kwargs = {
+                    "ssl_context": ssl_context,
+                    "server_hostname": server_hostname,
+                    "timeout": timeout,
+                }
+                with Trace("start_tls", logger, request, kwargs) as trace:
+                    stream = stream.start_tls(**kwargs)
+                    trace.return_value = stream
+
+                # Determine if we should be using HTTP/1.1 or HTTP/2
+                ssl_object = stream.get_extra_info("ssl_object")
+                http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+
+                # Create the HTTP/1.1 or HTTP/2 connection
+                if http2_negotiated or (self._http2 and not self._http1):
+                    from .http2 import HTTP2Connection
+
+                    self._connection = HTTP2Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+                else:
+                    self._connection = HTTP11Connection(
+                        origin=self._remote_origin,
+                        stream=stream,
+                        keepalive_expiry=self._keepalive_expiry,
+                    )
+
+                self._connected = True
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        self._connection.close()
+
+    def info(self) -> str:
+        return self._connection.info()
+
+    def is_connected(self) -> bool:
+        return self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        return self._connection.is_closed()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/interfaces.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/interfaces.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e66bd1ea2366aea4c8ebeb857e7e5a30f093342
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/interfaces.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import Generator
+
+from .._models import (
+    URL,
+    Extensions,
+    HeaderTypes,
+    Origin,
+    Request,
+    Response,
+    enforce_bytes,
+    enforce_headers,
+    enforce_url,
+    include_request_headers,
+)
+
+
+class RequestInterface:
+    def request(
+        self,
+        method: bytes | str,
+        url: URL | bytes | str,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.Iterator[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> Response:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            response.read()
+        finally:
+            response.close()
+        return response
+
+    @contextlib.contextmanager
+    def stream(
+        self,
+        method: bytes | str,
+        url: URL | bytes | str,
+        *,
+        headers: HeaderTypes = None,
+        content: bytes | typing.Iterator[bytes] | None = None,
+        extensions: Extensions | None = None,
+    ) -> Generator[Response]:
+        # Strict type checking on our parameters.
+        method = enforce_bytes(method, name="method")
+        url = enforce_url(url, name="url")
+        headers = enforce_headers(headers, name="headers")
+
+        # Include Host header, and optionally Content-Length or Transfer-Encoding.
+        headers = include_request_headers(headers, url=url, content=content)
+
+        request = Request(
+            method=method,
+            url=url,
+            headers=headers,
+            content=content,
+            extensions=extensions,
+        )
+        response = self.handle_request(request)
+        try:
+            yield response
+        finally:
+            response.close()
+
+    def handle_request(self, request: Request) -> Response:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class ConnectionInterface(RequestInterface):
+    def close(self) -> None:
+        raise NotImplementedError()  # pragma: no cover
+
+    def info(self) -> str:
+        raise NotImplementedError()  # pragma: no cover
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        raise NotImplementedError()  # pragma: no cover
+
+    def is_connected(self) -> bool:
+        """
+        Return `True` if the connection is open (the underlying socket has been
+        established).  A connection in the NEW state (just created but not yet
+        connected) returns `False`.
+
+        Note: for some implementations `is_connected() != not is_closed()`.
+        The default implementation returns `not self.is_closed()`, which is
+        correct for connections that are never in the NEW (pre-TCP) state.
+        """
+        return not self.is_closed()  # pragma: no cover
+
+    def is_available(self) -> bool:
+        """
+        Return `True` if the connection is currently able to accept an
+        outgoing request.
+
+        An HTTP/1.1 connection will only be available if it is currently idle.
+
+        An HTTP/2 connection will be available so long as the stream ID space is
+        not yet exhausted, and the connection is not in an error state.
+
+        While the connection is being established we may not yet know if it is going
+        to result in an HTTP/1.1 or HTTP/2 connection. The connection should be
+        treated as being available, but might ultimately raise `NewConnectionRequired`
+        required exceptions if multiple requests are attempted over a connection
+        that ends up being established as HTTP/1.1.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def has_expired(self) -> bool:
+        """
+        Return `True` if the connection is in a state where it should be closed.
+
+        This either means that the connection is idle and it has passed the
+        expiry time on its keep-alive, or that server has sent an EOF.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def is_idle(self) -> bool:
+        """
+        Return `True` if the connection is currently idle.
+        """
+        raise NotImplementedError()  # pragma: no cover
+
+    def can_multiplex(self) -> bool:
+        """
+        Return `True` if the connection can serve multiple requests
+        concurrently, such as an established HTTP/2 connection.
+
+        The default covers HTTP/1.1-style implementations, which serve a
+        single request at a time.
+        """
+        return False
+
+    def is_closed(self) -> bool:
+        """
+        Return `True` if the connection has been closed.
+
+        Used when a response is closed to determine if the connection may be
+        returned to the connection pool or not.
+        """
+        raise NotImplementedError()  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/socks_proxy.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/socks_proxy.py
new file mode 100644
index 0000000000000000000000000000000000000000..b49a576e11190e46599eb2c10c95063c1f2240fa
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_sync/socks_proxy.py
@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import logging
+import ssl
+
+import socksio
+
+from .._backends.sync import SyncBackend
+from .._backends.base import NetworkBackend, NetworkStream
+from .._exceptions import ConnectionNotAvailable, ProxyError
+from .._models import URL, Origin, Request, Response, enforce_bytes, enforce_url
+from .._ssl import default_ssl_context
+from .._synchronization import Lock
+from .._trace import Trace
+from .connection_pool import ConnectionPool
+from .http11 import HTTP11Connection
+from .interfaces import ConnectionInterface
+
+logger = logging.getLogger("httpcore2.socks")
+
+
+AUTH_METHODS = {
+    b"\x00": "NO AUTHENTICATION REQUIRED",
+    b"\x01": "GSSAPI",
+    b"\x02": "USERNAME/PASSWORD",
+    b"\xff": "NO ACCEPTABLE METHODS",
+}
+
+REPLY_CODES = {
+    b"\x00": "Succeeded",
+    b"\x01": "General SOCKS server failure",
+    b"\x02": "Connection not allowed by ruleset",
+    b"\x03": "Network unreachable",
+    b"\x04": "Host unreachable",
+    b"\x05": "Connection refused",
+    b"\x06": "TTL expired",
+    b"\x07": "Command not supported",
+    b"\x08": "Address type not supported",
+}
+
+
+def _init_socks5_connection(
+    stream: NetworkStream,
+    *,
+    host: bytes,
+    port: int,
+    auth: tuple[bytes, bytes] | None = None,
+    timeouts: dict[str, float | None] | None = None,
+) -> None:
+    timeouts = timeouts or {}
+    write_timeout = timeouts.get("write", None)
+    read_timeout = timeouts.get("read", None)
+    conn = socksio.socks5.SOCKS5Connection()
+
+    # Auth method request
+    auth_method = (
+        socksio.socks5.SOCKS5AuthMethod.NO_AUTH_REQUIRED
+        if auth is None
+        else socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD
+    )
+    conn.send(socksio.socks5.SOCKS5AuthMethodsRequest([auth_method]))
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes, timeout=write_timeout)
+
+    # Auth method response
+    incoming_bytes = stream.read(max_bytes=4096, timeout=read_timeout)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socksio.socks5.SOCKS5AuthReply)
+    if response.method != auth_method:
+        requested = AUTH_METHODS.get(auth_method, "UNKNOWN")
+        responded = AUTH_METHODS.get(response.method, "UNKNOWN")
+        raise ProxyError(f"Requested {requested} from proxy server, but got {responded}.")
+
+    if response.method == socksio.socks5.SOCKS5AuthMethod.USERNAME_PASSWORD:
+        # Username/password request
+        assert auth is not None
+        username, password = auth
+        conn.send(socksio.socks5.SOCKS5UsernamePasswordRequest(username, password))
+        outgoing_bytes = conn.data_to_send()
+        stream.write(outgoing_bytes, timeout=write_timeout)
+
+        # Username/password response
+        incoming_bytes = stream.read(max_bytes=4096, timeout=read_timeout)
+        response = conn.receive_data(incoming_bytes)
+        assert isinstance(response, socksio.socks5.SOCKS5UsernamePasswordReply)
+        if not response.success:
+            raise ProxyError("Invalid username/password")
+
+    # Connect request
+    conn.send(socksio.socks5.SOCKS5CommandRequest.from_address(socksio.socks5.SOCKS5Command.CONNECT, (host, port)))
+    outgoing_bytes = conn.data_to_send()
+    stream.write(outgoing_bytes, timeout=write_timeout)
+
+    # Connect response
+    incoming_bytes = stream.read(max_bytes=4096, timeout=read_timeout)
+    response = conn.receive_data(incoming_bytes)
+    assert isinstance(response, socksio.socks5.SOCKS5Reply)
+    if response.reply_code != socksio.socks5.SOCKS5ReplyCode.SUCCEEDED:
+        reply_code = REPLY_CODES.get(response.reply_code, "UNKOWN")
+        raise ProxyError(f"Proxy Server could not connect: {reply_code}.")
+
+
+class SOCKSProxy(ConnectionPool):  # pragma: no cover
+    """
+    A connection pool that sends requests via an HTTP proxy.
+    """
+
+    def __init__(
+        self,
+        proxy_url: URL | bytes | str,
+        proxy_auth: tuple[bytes | str, bytes | str] | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        max_connections: int | None = 10,
+        max_keepalive_connections: int | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        retries: int = 0,
+        network_backend: NetworkBackend | None = None,
+    ) -> None:
+        """
+        A connection pool for making HTTP requests.
+
+        Parameters:
+            proxy_url: The URL to use when connecting to the proxy server.
+                For example `"http://127.0.0.1:8080/"`.
+            ssl_context: An SSL context to use for verifying connections.
+                If not specified, the default `httpcore2.default_ssl_context()`
+                will be used.
+            max_connections: The maximum number of concurrent HTTP connections that
+                the pool should allow. Any attempt to send a request on a pool that
+                would exceed this amount will block until a connection is available.
+            max_keepalive_connections: The maximum number of idle HTTP connections
+                that will be maintained in the pool.
+            keepalive_expiry: The duration in seconds that an idle HTTP connection
+                may be maintained for before being expired from the pool.
+            http1: A boolean indicating if HTTP/1.1 requests should be supported
+                by the connection pool. Defaults to True.
+            http2: A boolean indicating if HTTP/2 requests should be supported by
+                the connection pool. Defaults to False.
+            retries: The maximum number of retries when trying to establish
+                a connection.
+            local_address: Local address to connect from. Can also be used to
+                connect using a particular address family. Using
+                `local_address="0.0.0.0"` will connect using an `AF_INET` address
+                (IPv4), while using `local_address="::"` will connect using an
+                `AF_INET6` address (IPv6).
+            uds: Path to a Unix Domain Socket to use instead of TCP sockets.
+            network_backend: A backend instance to use for handling network I/O.
+        """
+        super().__init__(
+            ssl_context=ssl_context,
+            max_connections=max_connections,
+            max_keepalive_connections=max_keepalive_connections,
+            keepalive_expiry=keepalive_expiry,
+            http1=http1,
+            http2=http2,
+            network_backend=network_backend,
+            retries=retries,
+        )
+        self._ssl_context = ssl_context
+        self._proxy_url = enforce_url(proxy_url, name="proxy_url")
+        if proxy_auth is not None:
+            username, password = proxy_auth
+            username_bytes = enforce_bytes(username, name="proxy_auth")
+            password_bytes = enforce_bytes(password, name="proxy_auth")
+            self._proxy_auth: tuple[bytes, bytes] | None = (
+                username_bytes,
+                password_bytes,
+            )
+        else:
+            self._proxy_auth = None
+
+    def create_connection(self, origin: Origin) -> ConnectionInterface:
+        return Socks5Connection(
+            proxy_origin=self._proxy_url.origin,
+            remote_origin=origin,
+            proxy_auth=self._proxy_auth,
+            ssl_context=self._ssl_context,
+            keepalive_expiry=self._keepalive_expiry,
+            http1=self._http1,
+            http2=self._http2,
+            network_backend=self._network_backend,
+        )
+
+
+class Socks5Connection(ConnectionInterface):
+    def __init__(
+        self,
+        proxy_origin: Origin,
+        remote_origin: Origin,
+        proxy_auth: tuple[bytes, bytes] | None = None,
+        ssl_context: ssl.SSLContext | None = None,
+        keepalive_expiry: float | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        network_backend: NetworkBackend | None = None,
+    ) -> None:
+        self._proxy_origin = proxy_origin
+        self._remote_origin = remote_origin
+        self._proxy_auth = proxy_auth
+        self._ssl_context = ssl_context
+        self._keepalive_expiry = keepalive_expiry
+        self._http1 = http1
+        self._http2 = http2
+
+        self._network_backend: NetworkBackend = SyncBackend() if network_backend is None else network_backend
+        self._connect_lock = Lock()
+        self._connection: ConnectionInterface | None = None
+        self._connect_failed = False
+
+    def handle_request(self, request: Request) -> Response:
+        timeouts = request.extensions.get("timeout", {})
+        sni_hostname = request.extensions.get("sni_hostname", None)
+        timeout = timeouts.get("connect", None)
+
+        with self._connect_lock:
+            if self._connection is None:
+                try:
+                    # Connect to the proxy
+                    kwargs = {
+                        "host": self._proxy_origin.host.decode("ascii"),
+                        "port": self._proxy_origin.port,
+                        "timeout": timeout,
+                    }
+                    with Trace("connect_tcp", logger, request, kwargs) as trace:
+                        stream = self._network_backend.connect_tcp(**kwargs)
+                        trace.return_value = stream
+
+                    # Connect to the remote host using socks5
+                    kwargs = {
+                        "stream": stream,
+                        "host": self._remote_origin.host.decode("ascii"),
+                        "port": self._remote_origin.port,
+                        "auth": self._proxy_auth,
+                        "timeouts": timeouts,
+                    }
+                    with Trace("setup_socks5_connection", logger, request, kwargs) as trace:
+                        _init_socks5_connection(**kwargs)
+                        trace.return_value = stream
+
+                    # Upgrade the stream to SSL
+                    if self._remote_origin.scheme in (b"https", b"wss"):
+                        ssl_context = default_ssl_context() if self._ssl_context is None else self._ssl_context
+                        alpn_protocols = (
+                            (["h2", "http/1.1"] if self._http1 else ["h2"]) if self._http2 else ["http/1.1"]
+                        )
+                        ssl_context.set_alpn_protocols(alpn_protocols)
+
+                        kwargs = {
+                            "ssl_context": ssl_context,
+                            "server_hostname": sni_hostname or self._remote_origin.host.decode("ascii"),
+                            "timeout": timeout,
+                        }
+                        with Trace("start_tls", logger, request, kwargs) as trace:
+                            stream = stream.start_tls(**kwargs)
+                            trace.return_value = stream
+
+                    # Determine if we should be using HTTP/1.1 or HTTP/2
+                    ssl_object = stream.get_extra_info("ssl_object")
+                    http2_negotiated = ssl_object is not None and ssl_object.selected_alpn_protocol() == "h2"
+
+                    # Create the HTTP/1.1 or HTTP/2 connection
+                    if http2_negotiated or (self._http2 and not self._http1):  # pragma: no cover
+                        from .http2 import HTTP2Connection
+
+                        self._connection = HTTP2Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                    else:
+                        self._connection = HTTP11Connection(
+                            origin=self._remote_origin,
+                            stream=stream,
+                            keepalive_expiry=self._keepalive_expiry,
+                        )
+                except Exception as exc:
+                    self._connect_failed = True
+                    raise exc
+            elif not self._connection.is_available():  # pragma: no cover
+                raise ConnectionNotAvailable()
+
+        return self._connection.handle_request(request)
+
+    def can_handle_request(self, origin: Origin) -> bool:
+        return origin == self._remote_origin
+
+    def close(self) -> None:
+        if self._connection is not None:
+            self._connection.close()
+
+    def is_connected(self) -> bool:
+        return self._connection is not None and self._connection.is_connected()
+
+    def is_available(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            # If HTTP/2 support is enabled, and the resulting connection could
+            # end up as HTTP/2 then we should indicate the connection as being
+            # available to service multiple requests.
+            return (
+                self._http2 and (self._remote_origin.scheme == b"https" or not self._http1) and not self._connect_failed
+            )
+        return self._connection.is_available()
+
+    def has_expired(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.has_expired()
+
+    def is_idle(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.is_idle()
+
+    def is_closed(self) -> bool:
+        if self._connection is None:  # pragma: no cover
+            return self._connect_failed
+        return self._connection.is_closed()
+
+    def info(self) -> str:
+        if self._connection is None:  # pragma: no cover
+            return "CONNECTION FAILED" if self._connect_failed else "CONNECTING"
+        return self._connection.info()
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__} [{self.info()}]>"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_synchronization.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_synchronization.py
new file mode 100644
index 0000000000000000000000000000000000000000..87bb9db0574274101f2d0f012b97dacd0ea08ec8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_synchronization.py
@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import threading
+import types
+
+from ._exceptions import ExceptionMapping, PoolTimeout, map_exceptions
+
+# Our async synchronization primitives use either 'anyio' or 'trio' depending
+# on if they're running under asyncio or trio.
+
+try:
+    import trio
+except (ImportError, NotImplementedError):  # pragma: no cover
+    trio = None  # type: ignore
+
+try:
+    import anyio
+except ImportError:  # pragma: no cover
+    anyio = None  # type: ignore
+
+try:
+    import sniffio
+except ImportError:  # pragma: no cover
+    sniffio = None  # type: ignore
+
+
+def current_async_library() -> str:
+    # Determine if we're running under trio or asyncio.
+    # See https://sniffio.readthedocs.io/en/latest/
+    if sniffio is None:  # pragma: no cover
+        environment = "asyncio"
+    else:
+        environment = sniffio.current_async_library()
+
+    if environment not in ("asyncio", "trio"):  # pragma: no cover
+        raise RuntimeError("Running under an unsupported async environment.")
+
+    if environment == "asyncio" and anyio is None:  # pragma: no cover
+        raise RuntimeError("Running with asyncio requires installation of 'httpcore[asyncio]'.")
+
+    if environment == "trio" and trio is None:  # pragma: no cover
+        raise RuntimeError("Running with trio requires installation of 'httpcore[trio]'.")
+
+    return environment
+
+
+class AsyncLock:
+    """
+    This is a standard lock.
+
+    In the sync case `Lock` provides thread locking.
+    In the async case `AsyncLock` provides async locking.
+    """
+
+    def __init__(self) -> None:
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a lock with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_lock = trio.Lock()
+        elif self._backend == "asyncio":
+            self._anyio_lock = anyio.Lock(fast_acquire=True)
+
+    async def __aenter__(self) -> AsyncLock:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            await self._trio_lock.acquire()
+        elif self._backend == "asyncio":
+            await self._anyio_lock.acquire()
+
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        if self._backend == "trio":
+            self._trio_lock.release()
+        elif self._backend == "asyncio":
+            self._anyio_lock.release()
+
+
+class AsyncThreadLock:
+    """
+    This is a threading-only lock for no-I/O contexts.
+
+    In the sync case `ThreadLock` provides thread locking.
+    In the async case `AsyncThreadLock` is a no-op.
+    """
+
+    def __enter__(self) -> AsyncThreadLock:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        pass
+
+
+class AsyncEvent:
+    def __init__(self) -> None:
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a lock with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_event = trio.Event()
+        elif self._backend == "asyncio":
+            self._anyio_event = anyio.Event()
+
+    def set(self) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            self._trio_event.set()
+        elif self._backend == "asyncio":
+            self._anyio_event.set()
+
+    async def wait(self, timeout: float | None = None) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            trio_exc_map: ExceptionMapping = {trio.TooSlowError: PoolTimeout}
+            timeout_or_inf = float("inf") if timeout is None else timeout
+            with map_exceptions(trio_exc_map):
+                with trio.fail_after(timeout_or_inf):
+                    await self._trio_event.wait()
+        elif self._backend == "asyncio":
+            anyio_exc_map: ExceptionMapping = {TimeoutError: PoolTimeout}
+            with map_exceptions(anyio_exc_map):
+                with anyio.fail_after(timeout):
+                    await self._anyio_event.wait()
+
+
+class AsyncSemaphore:
+    def __init__(self, bound: int) -> None:
+        self._bound = bound
+        self._backend = ""
+
+    def setup(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a semaphore with the correct implementation.
+        """
+        self._backend = current_async_library()
+        if self._backend == "trio":
+            self._trio_semaphore = trio.Semaphore(initial_value=self._bound, max_value=self._bound)
+        elif self._backend == "asyncio":
+            self._anyio_semaphore = anyio.Semaphore(initial_value=self._bound, max_value=self._bound, fast_acquire=True)
+
+    async def acquire(self) -> None:
+        if not self._backend:
+            self.setup()
+
+        if self._backend == "trio":
+            await self._trio_semaphore.acquire()
+        elif self._backend == "asyncio":
+            await self._anyio_semaphore.acquire()
+
+    def acquire_if_available(self) -> bool:
+        """
+        Acquire a permit if one is immediately available, without blocking.
+        Returns True if a permit was acquired.
+
+        Like `release()`, this requires `setup()` to have run, which any
+        prior `acquire()` call ensures.
+        """
+        if self._backend == "trio":
+            try:
+                self._trio_semaphore.acquire_nowait()
+            except trio.WouldBlock:
+                return False
+            return True
+        elif self._backend == "asyncio":
+            try:
+                self._anyio_semaphore.acquire_nowait()
+            except anyio.WouldBlock:
+                return False
+            return True
+        return False  # pragma: no cover
+
+    async def release(self) -> None:
+        if self._backend == "trio":
+            self._trio_semaphore.release()
+        elif self._backend == "asyncio":
+            self._anyio_semaphore.release()
+
+
+class AsyncShieldCancellation:
+    # For certain portions of our codebase where we're dealing with
+    # closing connections during exception handling we want to shield
+    # the operation from being cancelled.
+    #
+    # with AsyncShieldCancellation():
+    #     ... # clean-up operations, shielded from cancellation.
+
+    def __init__(self) -> None:
+        """
+        Detect if we're running under 'asyncio' or 'trio' and create
+        a shielded scope with the correct implementation.
+        """
+        self._backend = current_async_library()
+
+        if self._backend == "trio":
+            self._trio_shield = trio.CancelScope(shield=True)
+        elif self._backend == "asyncio":
+            self._anyio_shield = anyio.CancelScope(shield=True)
+
+    def __enter__(self) -> AsyncShieldCancellation:
+        if self._backend == "trio":
+            self._trio_shield.__enter__()
+        elif self._backend == "asyncio":
+            self._anyio_shield.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        if self._backend == "trio":
+            self._trio_shield.__exit__(exc_type, exc_value, traceback)
+        elif self._backend == "asyncio":
+            self._anyio_shield.__exit__(exc_type, exc_value, traceback)
+
+
+# Our thread-based synchronization primitives...
+
+
+class Lock:
+    """
+    This is a standard lock.
+
+    In the sync case `Lock` provides thread locking.
+    In the async case `AsyncLock` provides async locking.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+
+    def __enter__(self) -> Lock:
+        self._lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self._lock.release()
+
+
+class ThreadLock:
+    """
+    This is a threading-only lock for no-I/O contexts.
+
+    In the sync case `ThreadLock` provides thread locking.
+    In the async case `AsyncThreadLock` is a no-op.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+
+    def __enter__(self) -> ThreadLock:
+        self._lock.acquire()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        self._lock.release()
+
+
+class Event:
+    def __init__(self) -> None:
+        self._event = threading.Event()
+
+    def set(self) -> None:
+        self._event.set()
+
+    def wait(self, timeout: float | None = None) -> None:
+        if timeout == float("inf"):  # pragma: no cover
+            timeout = None
+        if not self._event.wait(timeout=timeout):
+            raise PoolTimeout()  # pragma: no cover
+
+
+class Semaphore:
+    def __init__(self, bound: int) -> None:
+        self._semaphore = threading.Semaphore(value=bound)
+
+    def acquire(self) -> None:
+        self._semaphore.acquire()
+
+    def acquire_if_available(self) -> bool:
+        return self._semaphore.acquire(blocking=False)
+
+    def release(self) -> None:
+        self._semaphore.release()
+
+
+class ShieldCancellation:
+    # Thread-synchronous codebases don't support cancellation semantics.
+    # We have this class because we need to mirror the async and sync
+    # cases within our package, but it's just a no-op.
+    def __enter__(self) -> ShieldCancellation:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_trace.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_trace.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e33ec7042c710cc5aedce6653e78efb366d4a56
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_trace.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import inspect
+import logging
+import types
+import typing
+
+from ._models import Request
+
+
+class Trace:
+    def __init__(
+        self,
+        name: str,
+        logger: logging.Logger,
+        request: Request | None = None,
+        kwargs: dict[str, typing.Any] | None = None,
+    ) -> None:
+        self.name = name
+        self.logger = logger
+        self.trace_extension = None if request is None else request.extensions.get("trace")
+        self.debug = self.logger.isEnabledFor(logging.DEBUG)
+        self.kwargs = kwargs or {}
+        self.return_value: typing.Any = None
+        self.should_trace = self.debug or self.trace_extension is not None
+        self.prefix = self.logger.name.split(".")[-1]
+
+    def trace(self, name: str, info: dict[str, typing.Any]) -> None:
+        if self.trace_extension is not None:
+            prefix_and_name = f"{self.prefix}.{name}"
+            ret = self.trace_extension(prefix_and_name, info)
+            if inspect.iscoroutine(ret):  # pragma: no cover
+                raise TypeError(
+                    "If you are using a synchronous interface, "
+                    "the callback of the `trace` extension should "
+                    "be a normal function instead of an asynchronous function."
+                )
+
+        if self.debug:
+            if not info or "return_value" in info and info["return_value"] is None:
+                message = name
+            else:
+                args = " ".join([f"{key}={value!r}" for key, value in info.items()])
+                message = f"{name} {args}"
+            self.logger.debug(message)
+
+    def __enter__(self) -> Trace:
+        if self.should_trace:
+            info = self.kwargs
+            self.trace(f"{self.name}.started", info)
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        if self.should_trace:
+            if exc_value is None:
+                info = {"return_value": self.return_value}
+                self.trace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                self.trace(f"{self.name}.failed", info)
+
+    async def atrace(self, name: str, info: dict[str, typing.Any]) -> None:
+        if self.trace_extension is not None:
+            prefix_and_name = f"{self.prefix}.{name}"
+            coro = self.trace_extension(prefix_and_name, info)
+            if not inspect.iscoroutine(coro):  # pragma: no cover
+                raise TypeError(
+                    "If you're using an asynchronous interface, "
+                    "the callback of the `trace` extension should "
+                    "be an asynchronous function rather than a normal function."
+                )
+            await coro
+
+        if self.debug:
+            if not info or "return_value" in info and info["return_value"] is None:
+                message = name
+            else:
+                args = " ".join([f"{key}={value!r}" for key, value in info.items()])
+                message = f"{name} {args}"
+            self.logger.debug(message)
+
+    async def __aenter__(self) -> Trace:
+        if self.should_trace:
+            info = self.kwargs
+            await self.atrace(f"{self.name}.started", info)
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: types.TracebackType | None = None,
+    ) -> None:
+        if self.should_trace:
+            if exc_value is None:
+                info = {"return_value": self.return_value}
+                await self.atrace(f"{self.name}.complete", info)
+            else:
+                info = {"exception": exc_value}
+                await self.atrace(f"{self.name}.failed", info)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..4816b8d6bb99bc66cd9dd2c7574534b2bbb2e120
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/_utils.py
@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import select
+import socket
+import sys
+import typing
+from collections.abc import (
+    AsyncIterable,
+    AsyncIterator,
+    Generator,
+    Iterable,
+    Iterator,
+)
+from contextlib import AbstractAsyncContextManager, aclosing, contextmanager, nullcontext
+from types import AsyncGeneratorType
+
+T = typing.TypeVar("T")
+
+
+def is_socket_readable(sock: socket.socket | None) -> bool:
+    """
+    Return whether a socket, as identified by its file descriptor, is readable.
+    "A socket is readable" means that the read buffer isn't empty, i.e. that calling
+    .recv() on it would immediately return some data.
+    """
+    # NOTE: we want check for readability without actually attempting to read, because
+    # we don't want to block forever if it's not readable.
+
+    # In the case that the socket no longer exists, or cannot return a file
+    # descriptor, we treat it as being readable, as if it the next read operation
+    # on it is ready to return the terminating `b""`.
+    sock_fd = None if sock is None else sock.fileno()
+    if sock_fd is None or sock_fd < 0:  # pragma: no cover
+        return True
+
+    # The implementation below was stolen from:
+    # https://github.com/python-trio/trio/blob/20ee2b1b7376db637435d80e266212a35837ddcc/trio/_socket.py#L471-L478
+    # See also: https://github.com/encode/httpcore/pull/193#issuecomment-703129316
+
+    # Use select.select on Windows, and when poll is unavailable and select.poll
+    # everywhere else. (E.g. When eventlet is in use. See #327)
+    if sys.platform == "win32" or getattr(select, "poll", None) is None:  # pragma: no cover
+        rready, _, _ = select.select([sock_fd], [], [], 0)
+        return bool(rready)
+    p = select.poll()
+    p.register(sock_fd, select.POLLIN)
+    return bool(p.poll(0))
+
+
+def safe_async_iterate(
+    iterable_or_iterator: AsyncIterable[T] | AsyncIterator[T], /
+) -> AbstractAsyncContextManager[AsyncIterator[T]]:
+    iterator = (
+        iterable_or_iterator if isinstance(iterable_or_iterator, AsyncIterator) else iterable_or_iterator.__aiter__()
+    )
+    if isinstance(iterator, AsyncGeneratorType):
+        return aclosing(iterator)
+    return nullcontext(iterator)
+
+
+@contextmanager
+def safe_iterate(iterable_or_iterator: Iterable[T] | Iterator[T], /) -> Generator[Iterator[T], None, None]:
+    # This is boilerplate code, only needed to make unasync happy
+    iterator = iterable_or_iterator if isinstance(iterable_or_iterator, Iterator) else iterable_or_iterator.__iter__()
+    yield iterator
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpcore2/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/INSTALLER b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/INSTALLER
new file mode 100644
index 0000000000000000000000000000000000000000..a1b589e38a32041e49332e5e81c2d363dc418d68
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/INSTALLER
@@ -0,0 +1 @@
+pip
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/METADATA b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/METADATA
new file mode 100644
index 0000000000000000000000000000000000000000..b7a6e704f6f9e0017df237eda397fb51800fad51
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/METADATA
@@ -0,0 +1,225 @@
+Metadata-Version: 2.5
+Name: httpx2
+Version: 2.15.1
+Summary: The next generation HTTP client.
+Project-URL: Changelog, https://github.com/pydantic/httpx2/blob/main/src/httpx2/CHANGELOG.md
+Project-URL: Homepage, https://github.com/pydantic/httpx2
+Project-URL: Source, https://github.com/pydantic/httpx2
+Author-email: Tom Christie <tom@tomchristie.com>
+Maintainer-email: "Pydantic Services Inc." <engineering@pydantic.dev>
+License-Expression: BSD-3-Clause
+License-File: LICENSE.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Web Environment
+Classifier: Framework :: AnyIO
+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.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.10; sys_platform != 'emscripten'
+Requires-Dist: httpcore2==2.15.1; sys_platform != 'emscripten'
+Requires-Dist: httpx2-jsfetch; sys_platform == 'emscripten' and python_version >= '3.12'
+Requires-Dist: idna>=3.18
+Requires-Dist: truststore>=0.10; sys_platform != 'emscripten'
+Requires-Dist: typing-extensions>=4.5.0; python_version < '3.13'
+Provides-Extra: brotli
+Requires-Dist: brotli>=1.2.0; (platform_python_implementation == 'CPython') and extra == 'brotli'
+Requires-Dist: brotlicffi>=1.2.0.2; (platform_python_implementation != 'CPython') and extra == 'brotli'
+Provides-Extra: cli
+Requires-Dist: click>=8.4.2; extra == 'cli'
+Requires-Dist: pygments==2.*; extra == 'cli'
+Requires-Dist: rich<16,>=10; extra == 'cli'
+Provides-Extra: http2
+Requires-Dist: h2<5,>=3; extra == 'http2'
+Provides-Extra: socks
+Requires-Dist: socksio==1.*; extra == 'socks'
+Provides-Extra: ws
+Requires-Dist: wsproto>=1.2; extra == 'ws'
+Provides-Extra: zstd
+Requires-Dist: backports-zstd>=1.0.0; (python_version <= '3.13') and extra == 'zstd'
+Description-Content-Type: text/markdown
+
+<h1 align="center">HTTPX2</h1>
+
+<p align="center"><em>A next-generation HTTP client for Python.</em></p>
+
+<p align="center">
+<a href="https://github.com/pydantic/httpx2/actions"><img src="https://github.com/pydantic/httpx2/workflows/Test%20Suite/badge.svg" alt="Test Suite"></a>
+<a href="https://pypi.org/project/httpx2/"><img src="https://badge.fury.io/py/httpx2.svg" alt="Package version"></a>
+<a href="https://pydantic.dev/docs/logfire/join-slack/"><img src="https://img.shields.io/badge/Slack-Join%20Slack-4A154B?logo=slack" alt="Join Slack"></a>
+</p>
+
+HTTPX2 is a fully featured HTTP client library for Python. It includes **an integrated command line client**, has support for both **HTTP/1.1 and HTTP/2**, and provides both **sync and async APIs**.
+
+> [!NOTE]
+> HTTPX2 is a continuation of the wonderful work started by [@lovelydinosaur](https://github.com/lovelydinosaur) and the broader HTTPX community. We're enormously grateful for everything that has gone into HTTPX over the years - it has been a foundational piece of the modern Python ecosystem, and this project would not exist without it.
+>
+> With HTTPX itself seeing limited activity recently, Pydantic is picking up stewardship under the HTTPX2 name so that users have a reliably maintained path forward - including timely security updates for a library that sits in the critical path of so many production systems. Our aim is to honour the original project's design, keep it stable for everyone relying on it, and continue evolving it carefully. Thank you to [@lovelydinosaur](https://github.com/lovelydinosaur) and every past contributor for laying such a strong foundation. 💙
+
+---
+
+Install HTTPX2 using pip:
+
+```shell
+pip install httpx2
+```
+
+Now, let's get started:
+
+```pycon
+>>> import httpx2
+>>> r = httpx2.get('https://www.example.org/')
+>>> r
+<Response [200 OK]>
+>>> r.status_code
+200
+>>> r.headers['content-type']
+'text/html; charset=UTF-8'
+>>> r.text
+'<!doctype html>\n<html>\n<head>\n<title>Example Domain</title>...'
+```
+
+Or, using the command-line client.
+
+```shell
+pip install 'httpx2[cli]'  # The command line client is an optional dependency.
+```
+
+Which now allows us to use HTTPX2 directly from the command-line:
+
+```shell
+httpx2 --help
+```
+
+## Features
+
+HTTPX2 builds on the well-established usability of `requests`, and gives you:
+
+* A broadly [requests-compatible API](https://pydantic.dev/docs/httpx2/guides/compatibility/).
+* An integrated command-line client.
+* HTTP/1.1 [and HTTP/2 support](https://pydantic.dev/docs/httpx2/guides/http2/).
+* Standard synchronous interface, but with [async support if you need it](https://pydantic.dev/docs/httpx2/guides/async/).
+* Ability to make requests directly to [WSGI applications](https://pydantic.dev/docs/httpx2/advanced/transports/#wsgi-transport) or [ASGI applications](https://pydantic.dev/docs/httpx2/advanced/transports/#asgi-transport).
+* Strict timeouts everywhere.
+* Fully type annotated.
+* 100% test coverage.
+
+Plus all the standard features of `requests`...
+
+* International Domains and URLs
+* Keep-Alive & Connection Pooling
+* Sessions with Cookie Persistence
+* Browser-style SSL Verification
+* Basic/Digest Authentication
+* Elegant Key/Value Cookies
+* Automatic Decompression
+* Automatic Content Decoding
+* Unicode Response Bodies
+* Multipart File Uploads
+* HTTP(S) Proxy Support
+* Connection Timeouts
+* Streaming Downloads
+* .netrc Support
+* Chunked Requests
+
+## Installation
+
+Install with pip:
+
+```shell
+pip install httpx2
+```
+
+Or, to include the optional HTTP/2 support, use:
+
+```shell
+pip install httpx2[http2]
+```
+
+## Documentation
+
+Project documentation is available at [https://pydantic.dev/docs/httpx2/](https://pydantic.dev/docs/httpx2/).
+
+For a run-through of all the basics, head over to the [QuickStart](https://pydantic.dev/docs/httpx2/get-started/quickstart/).
+
+For more advanced topics, see the [Advanced Usage](https://pydantic.dev/docs/httpx2/advanced/clients/) section, the [async support](https://pydantic.dev/docs/httpx2/guides/async/) section, or the [HTTP/2](https://pydantic.dev/docs/httpx2/guides/http2/) section.
+
+The [Developer Interface](https://pydantic.dev/docs/httpx2/api/api/) provides a comprehensive API reference.
+
+To find out about tools that integrate with HTTPX, see [Third Party Packages](https://pydantic.dev/docs/httpx2/community/third_party_packages/).
+
+## Observability with Pydantic Logfire
+
+Install Logfire with HTTPX instrumentation support:
+
+```shell
+pip install 'logfire[httpx]'
+```
+
+HTTPX2 works out of the box with [Pydantic Logfire](https://pydantic.dev/logfire), our observability platform built on OpenTelemetry. One line instruments every request, giving you traces, timings, and status codes with no other changes:
+
+```python
+import logfire
+import httpx2
+
+logfire.configure()
+logfire.instrument_httpx()
+
+httpx2.get("https://pydantic.dev/")
+```
+
+This works the same way for explicit `httpx2.Client()` and `httpx2.AsyncClient()` instances, and you can scope instrumentation to a single client by passing it in: `logfire.instrument_httpx(client)`. Pass `capture_all=True` to also record headers and bodies. See the [Logfire HTTPX docs](https://logfire.pydantic.dev/docs/integrations/http-clients/httpx/) for the full set of options.
+
+## Contribute
+
+If you want to contribute with HTTPX2 check out the [Contributing Guide](https://pydantic.dev/docs/httpx2/community/contributing/) to learn how to start.
+
+## Dependencies
+
+The HTTPX2 project relies on these excellent libraries:
+
+* `httpcore2` - The underlying transport implementation for `httpx2`.
+  * `h11` - HTTP/1.1 support.
+* `anyio` - Structured concurrency primitives, used to support both `asyncio` and `trio`.
+* `truststore` - SSL verification using the operating system's trust store.
+* `idna` - Internationalized domain name support.
+
+As well as these optional installs:
+
+* `h2` - HTTP/2 support. *(Optional, with `httpx2[http2]`)*
+* `socksio` - SOCKS proxy support. *(Optional, with `httpx2[socks]`)*
+* `rich` - Rich terminal support. *(Optional, with `httpx2[cli]`)*
+* `click` - Command line client support. *(Optional, with `httpx2[cli]`)*
+* `brotli` or `brotlicffi` - Decoding for "brotli" compressed responses. *(Optional, with `httpx2[brotli]`)*
+* `backports.zstd` - Decoding for "zstd" compressed responses on Python 3.13 and below. *(Optional, with `httpx2[zstd]`. On Python 3.14+, `zstd` is supported via the stdlib [`compression.zstd`](https://docs.python.org/3/library/compression.zstd.html) module when it is available, and the `httpx2[zstd]` extra installs nothing.)*
+
+A huge amount of credit is due to `requests` for the API layout that
+much of this work follows, as well as to `urllib3` for plenty of design
+inspiration around the lower-level networking details.
+
+---
+
+<p align="center"><i>HTTPX2 is <a href="https://github.com/pydantic/httpx2/blob/main/LICENSE.md">BSD licensed</a> code.<br/>Designed & crafted with care.</i><br/>&mdash; 🦋 &mdash;</p>
+
+## Release Information
+
+## 2.15.1 (October 19th, 2026)
+
+### Fixed
+
+* Configure the default SSL context once on Linux, instead of on every handshake. With OpenSSL older than 3.4, CPU usage grew over the lifetime of a reused client.
+  ([#1253](https://github.com/pydantic/httpx2/pull/1253))
+
+---
+
+[Full changelog](https://github.com/pydantic/httpx2/blob/main/src/httpx2/CHANGELOG.md)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/RECORD b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/RECORD
new file mode 100644
index 0000000000000000000000000000000000000000..87015d812938269893b36ac40a18884fd65c3813
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/RECORD
@@ -0,0 +1,68 @@
+../../../bin/httpx2,sha256=MdHLmSADJVk66KSczOOyT_m0DSWsxiCF1zv3z-KGh2o,247
+httpx2-2.15.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+httpx2-2.15.1.dist-info/METADATA,sha256=YPDnllYYKEgkds0Vt8Oho46ZGv_ijnXvHyC8TmoNWdA,9633
+httpx2-2.15.1.dist-info/RECORD,,
+httpx2-2.15.1.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+httpx2-2.15.1.dist-info/entry_points.txt,sha256=3uiZorRQlQAFNoHaDxuMsmkdjt3rUTmuBz81tLXFdQY,45
+httpx2-2.15.1.dist-info/licenses/LICENSE.md,sha256=fn1tuvf-Fg05_W6E_QLDPKuWvL6jTTaZjVRbzrShnDA,1589
+httpx2/__init__.py,sha256=BfjyqGaJJhHp5NsWDrQ7GJUjqr1zGXNoqV3vb5eUozo,2661
+httpx2/__pycache__/__init__.cpython-311.pyc,,
+httpx2/__pycache__/__version__.cpython-311.pyc,,
+httpx2/__pycache__/_alias.cpython-311.pyc,,
+httpx2/__pycache__/_api.cpython-311.pyc,,
+httpx2/__pycache__/_auth.cpython-311.pyc,,
+httpx2/__pycache__/_client.cpython-311.pyc,,
+httpx2/__pycache__/_config.cpython-311.pyc,,
+httpx2/__pycache__/_content.cpython-311.pyc,,
+httpx2/__pycache__/_decoders.cpython-311.pyc,,
+httpx2/__pycache__/_exceptions.cpython-311.pyc,,
+httpx2/__pycache__/_main.cpython-311.pyc,,
+httpx2/__pycache__/_models.cpython-311.pyc,,
+httpx2/__pycache__/_multipart.cpython-311.pyc,,
+httpx2/__pycache__/_sse.cpython-311.pyc,,
+httpx2/__pycache__/_status_codes.cpython-311.pyc,,
+httpx2/__pycache__/_types.cpython-311.pyc,,
+httpx2/__pycache__/_urlparse.cpython-311.pyc,,
+httpx2/__pycache__/_urls.cpython-311.pyc,,
+httpx2/__pycache__/_utils.cpython-311.pyc,,
+httpx2/__version__.py,sha256=XWKDNx4TZNJGkuO6vv16RvfV8lhdgdMIbQ8Bt0cR4UQ,158
+httpx2/_alias.py,sha256=Evn6S3BWugzd5XgDAYOsQf45_tAQpgae4JJ6U6n02Bw,2431
+httpx2/_api.py,sha256=IhvMLaySB7-pEER2l_qCbSDjTmG28hVPXIJJMdiHze0,14794
+httpx2/_auth.py,sha256=VUO3zJfK3GGOp3dnQqYrAu6Lkip-DpK2mutFPmVbjjA,11969
+httpx2/_client.py,sha256=-jlIqmap79Xt8JfG0T2SdhLGFzKLQ87vxL3V41CqqTs,75410
+httpx2/_config.py,sha256=DAJBDxmJX4GmlCqtNE1L1dgEr5sBmo8tvLcn48R2oTA,7438
+httpx2/_content.py,sha256=sNp9IVai11gXO_4P5Uka8XqrT_A8Ab5xkgRlKD4xeY0,8490
+httpx2/_decoders.py,sha256=C479GSHULT-xFz3Rr5TwZ0uUn2ih_afezn7QcgoIfAA,15046
+httpx2/_exceptions.py,sha256=69TPZgHvTkkjV1P0y5DSVOmDkxwCRsKhCfhd_qTTaVc,8857
+httpx2/_main.py,sha256=JT_VdROzHpKs8DNBIvXZXF2jYr6jxo0NVyk1FK6ff5A,15434
+httpx2/_models.py,sha256=0TnQxUoazWWZX2k9h2RB5V_kGO8nmfZH7GNh9pWw1NY,45738
+httpx2/_multipart.py,sha256=ksgIJarALvO7EcgDmc40GX6GyVO6XG0faszehXdRaTg,10018
+httpx2/_sse.py,sha256=IZ1Lf6NrgoZa7FP5-n_VhKhk0eEYFkPZtOC8g5JpQCk,7552
+httpx2/_status_codes.py,sha256=0CWpuD1dw8PYrt9f7epZ0bZZQEnmqe-z6FK_IzIeh14,6625
+httpx2/_transports/__init__.py,sha256=e65w9X4RMK9O_0Q6kPqpXr1ijeEf6b9xbl4KfrAYDCI,711
+httpx2/_transports/__pycache__/__init__.cpython-311.pyc,,
+httpx2/_transports/__pycache__/asgi.cpython-311.pyc,,
+httpx2/_transports/__pycache__/base.cpython-311.pyc,,
+httpx2/_transports/__pycache__/default.cpython-311.pyc,,
+httpx2/_transports/__pycache__/mock.cpython-311.pyc,,
+httpx2/_transports/__pycache__/wsgi.cpython-311.pyc,,
+httpx2/_transports/asgi.py,sha256=PWe4gtw8l2NqK5VusB4uprs6l46fJ4ewLX8FUEOozuk,5429
+httpx2/_transports/base.py,sha256=KY5zBVbdG6ge2sE-j0ZKyJ1C1LWBZVHQnOg0BdQ6idE,2584
+httpx2/_transports/default.py,sha256=j8Q6KILUca_3UTZqfyjpHF4xgxpLKao7tOZpMaIUjpc,13913
+httpx2/_transports/mock.py,sha256=3LZowN_YXbXezA2P4D4g29bCemTiT5Gr8U_vBvxtgxs,1209
+httpx2/_transports/wsgi.py,sha256=R5UApE_xXvl3BwKMgokN5irXiXGRFbOrtTdiKXFEBkI,4904
+httpx2/_types.py,sha256=pVETNjBR2OoWs9-sY7tRTAQM8sZx8-kNwZ4DjZcEYZU,2671
+httpx2/_urlparse.py,sha256=X-_rLDsC9QMIGc1FXr9DVRTYsLLB_SOdaCOtF2-DRIA,18323
+httpx2/_urls.py,sha256=t2wZOCuWtmP8vHnwq2hLhLZ_g2Y36K3SMpU0u_3J8CY,23184
+httpx2/_utils.py,sha256=-2nvGVPvYfJxZXPU-RbQXxGazILdRp5kJUJK98mF5R4,10524
+httpx2/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+httpx2/websockets/__init__.py,sha256=K66d2Zczl0Ewa0ey0Q2ETx5utzVH6n5G6J22mR3GbV0,1826
+httpx2/websockets/__pycache__/__init__.cpython-311.pyc,,
+httpx2/websockets/__pycache__/_api.cpython-311.pyc,,
+httpx2/websockets/__pycache__/_exceptions.cpython-311.pyc,,
+httpx2/websockets/__pycache__/_ping.cpython-311.pyc,,
+httpx2/websockets/__pycache__/_transport.cpython-311.pyc,,
+httpx2/websockets/_api.py,sha256=pNdsYOmhqeq5k8_DrtXK-w5QDAcKEq1FNwgBWF3j0Gc,63283
+httpx2/websockets/_exceptions.py,sha256=bpnBX9fDdkWh9jKWqqXAcQ_jsIPDRSuzUexxz_RPzqA,1290
+httpx2/websockets/_ping.py,sha256=M6Xmbap01-ldl1ejejmkjJbBgK1ulBj-_oaUoKciqrM,1258
+httpx2/websockets/_transport.py,sha256=pGtJcgy58Vi9246bj56yr-80qqpfUk6FapMFd8zw2Ls,11029
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/WHEEL b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/WHEEL
new file mode 100644
index 0000000000000000000000000000000000000000..39dc805011177e5b2a77e7afb5ec7187aeb3e34d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/WHEEL
@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/entry_points.txt b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/entry_points.txt
new file mode 100644
index 0000000000000000000000000000000000000000..38598b6f8f28e81f18ba4838452194abf01a5132
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/entry_points.txt
@@ -0,0 +1,2 @@
+[console_scripts]
+httpx2 = httpx2._main:main
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/licenses/LICENSE.md b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/licenses/LICENSE.md
new file mode 100644
index 0000000000000000000000000000000000000000..23b0ee02a488b0f2b49bd4199709daba331b0b03
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2-2.15.1.dist-info/licenses/LICENSE.md
@@ -0,0 +1,13 @@
+Copyright © 2026 to present Pydantic Services Inc. and individual contributors.
+Copyright © 2019, [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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a57e038da9d36e31753208ac2d226ed0eaf8e77
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__init__.py
@@ -0,0 +1,130 @@
+from .__version__ import __description__, __title__, __version__
+from ._alias import *
+from ._api import *
+from ._auth import *
+from ._client import *
+from ._config import *
+from ._content import *
+from ._exceptions import *
+from ._models import *
+from ._sse import *
+from ._status_codes import *
+from ._transports import *
+from ._types import *
+from ._urls import *
+
+__all__ = [
+    # __version__.py
+    "__description__",
+    "__title__",
+    "__version__",
+    # _alias.py
+    "alias_httpx",
+    # _api.py
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "query",
+    "request",
+    "stream",
+    "websocket",
+    # _auth.py
+    "Auth",
+    "BasicAuth",
+    "DigestAuth",
+    "FunctionAuth",
+    "NetRCAuth",
+    # _client.py
+    "AsyncClient",
+    "Client",
+    "USE_CLIENT_DEFAULT",
+    # _config.py
+    "create_ssl_context",
+    "Limits",
+    "Proxy",
+    "Timeout",
+    # _content.py
+    "ByteStream",
+    # _exceptions.py
+    "CloseError",
+    "ConnectError",
+    "ConnectTimeout",
+    "CookieConflict",
+    "DecodingError",
+    "HTTPError",
+    "HTTPStatusError",
+    "InvalidURL",
+    "LocalProtocolError",
+    "NetworkError",
+    "PoolTimeout",
+    "ProtocolError",
+    "ProxyError",
+    "ReadError",
+    "ReadTimeout",
+    "RemoteProtocolError",
+    "RequestError",
+    "RequestNotRead",
+    "ResponseNotRead",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "UnsupportedProtocol",
+    "WriteError",
+    "WriteTimeout",
+    # _models.py
+    "Cookies",
+    "Headers",
+    "Request",
+    "Response",
+    # _sse.py
+    "EventSource",
+    "ServerSentEvent",
+    "SSEError",
+    # _status_codes.py
+    "codes",
+    # _transports
+    "ASGITransport",
+    "AsyncBaseTransport",
+    "AsyncHTTPTransport",
+    "BaseTransport",
+    "HTTPTransport",
+    "MockTransport",
+    "WSGITransport",
+    # _types.py
+    "AsyncByteStream",
+    "SyncByteStream",
+    # _urls.py
+    "Origin",
+    "QueryParams",
+    "URL",
+]
+
+
+__locals = locals()
+for __name in __all__:
+    if not __name.startswith("__"):
+        setattr(__locals[__name], "__module__", "httpx2")  # noqa
+
+
+def __getattr__(name: str) -> object:  # pragma: no cover
+    if name == "main":
+        import warnings
+
+        warnings.warn(
+            "`httpx2.main` is deprecated and will be removed in a future release. "
+            "Use the `httpx2` CLI entry point instead.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        from ._main import main
+
+        return main
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9616008b5931a07de4bf8561e6967248d7cdf149
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__version__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__version__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c724e48ee2cb463d7b51f3a28c69e2c4fe2d9b88
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/__version__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_alias.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_alias.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..09989126ec08fbc450f8df0fd8513e151a9cccc5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_alias.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8a2717676e37d2bc4917a76ab7d22d5875527710
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_auth.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_auth.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..69008d74354588cb3e3a65dfddc4951e3fe0ef8b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_auth.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_client.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_client.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d782aabd7547a35c13a664853b2ce538b4c660ad
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_client.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_config.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_config.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9a07c63eecfc93c8d7f9d24392023bfc4279843c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_config.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_content.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_content.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..946c3a68dcc8b67bc26fabaceb52f2915b22bdcd
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_content.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_decoders.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_decoders.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..88b60da3280f22cf47e94c014bdc6e534fd97b47
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_decoders.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1c23314e0133c00ae3e4413f2e51adba1ba09811
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_main.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_main.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7b5b06d05ad4eb77a5e45d085b721dbea0e643bd
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_main.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_models.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_models.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..04f3b1b9e13a11d9d55a8e877c07d1c66c54d8a1
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_models.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_multipart.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_multipart.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c9bd99933716e5f75d48fcab69908afb4170c32
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_multipart.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_sse.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_sse.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e9895520a0340dcbb74abf8dc31a4c3fb45aa73
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_sse.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_status_codes.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_status_codes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..62ec2874a970b844be20d78302fb71ebe80f2a67
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_status_codes.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_types.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b66b1f7ab1e52649ea93fea1ecfd252cdd215d33
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_types.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urlparse.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urlparse.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..01f2add08b12cd4e10410fb95b7fef6abbbba017
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urlparse.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urls.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urls.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..15a940d97f69f4453155ac0115377fc71c433aa5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_urls.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9762a9753b560c1d839394b979e85e256101d695
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__pycache__/_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__version__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__version__.py
new file mode 100644
index 0000000000000000000000000000000000000000..5353a4ba3c7a1414347e8fb9048e8409b79539ec
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/__version__.py
@@ -0,0 +1,5 @@
+from importlib.metadata import version
+
+__title__ = "httpx2"
+__description__ = "A next generation HTTP client, for Python 3."
+__version__ = version("httpx2")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_alias.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_alias.py
new file mode 100644
index 0000000000000000000000000000000000000000..111e2cf436aa566fd5818c2d36307032a267eed6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_alias.py
@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import importlib
+import importlib.abc
+import importlib.machinery
+import importlib.util
+import sys
+from collections.abc import Sequence
+from types import ModuleType
+
+__all__ = ["alias_httpx"]
+
+
+class _AliasLoader(importlib.abc.Loader):
+    _original_spec: importlib.machinery.ModuleSpec | None
+
+    def __init__(self, real_name: str) -> None:
+        self._real_name = real_name
+
+    def create_module(self, spec: importlib.machinery.ModuleSpec) -> ModuleType:
+        module = importlib.import_module(self._real_name)
+        self._original_spec = module.__spec__
+        return module
+
+    def exec_module(self, module: ModuleType) -> None:
+        module.__spec__ = self._original_spec
+
+
+class _AliasFinder(importlib.abc.MetaPathFinder):
+    def __init__(self, alias: str, real: str) -> None:
+        self._alias = alias
+        self._real = real
+
+    def find_spec(
+        self,
+        fullname: str,
+        path: Sequence[str] | None = None,
+        target: ModuleType | None = None,
+    ) -> importlib.machinery.ModuleSpec | None:
+        if fullname != self._alias and not fullname.startswith(self._alias + "."):
+            return None
+        real_name = self._real + fullname.removeprefix(self._alias)
+        if real_name not in sys.modules and importlib.util.find_spec(real_name) is None:
+            return None
+        return importlib.machinery.ModuleSpec(fullname, _AliasLoader(real_name))
+
+
+def _alias(alias: str, module: ModuleType) -> None:
+    existing = sys.modules.get(alias)
+    if existing is not None and existing is not module:
+        raise RuntimeError(f"{alias} was already imported; call `alias_httpx()` before any `import {alias}`.")
+
+    if not any(isinstance(finder, _AliasFinder) and finder._alias == alias for finder in sys.meta_path):
+        sys.meta_path.insert(0, _AliasFinder(alias, module.__name__))
+    sys.modules[alias] = module
+
+
+def alias_httpx() -> None:
+    """
+    Make `import httpx` resolve to `httpx2`, and `import httpcore` to `httpcore2`, process-wide.
+
+    Intended for applications migrating from `httpx`, so that dependencies still
+    importing `httpx` or `httpcore` share the `httpx2` classes. Libraries should never call this.
+
+    Must be called before anything imports `httpx` or `httpcore`. Calling it again is a no-op.
+    """
+    import httpcore2
+    import httpx2
+
+    _alias("httpx", httpx2)
+    _alias("httpcore", httpcore2)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..a7a4ddc20ea6d6f1bceefc06cfa018ef18282e6f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_api.py
@@ -0,0 +1,532 @@
+from __future__ import annotations
+
+import typing
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from ._client import Client
+from ._config import (
+    DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+    DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    DEFAULT_QUEUE_SIZE,
+    DEFAULT_TIMEOUT_CONFIG,
+)
+from ._models import Response
+from ._types import (
+    AuthTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxyTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    TimeoutTypes,
+)
+from ._urls import URL
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+    from .websockets._api import WebSocketSession
+
+
+__all__ = [
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "query",
+    "request",
+    "stream",
+    "websocket",
+]
+
+
+def request(
+    method: str,
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> Response:
+    """Sends an HTTP request.
+
+    Parameters:
+        method: HTTP method for the new `Request` object: `GET`, `OPTIONS`, `HEAD`, `POST`, `PUT`, `PATCH`, `DELETE`,
+            or `QUERY`.
+        url: URL for the new `Request` object.
+        params: *(optional)* Query parameters to include in the URL, as a string, dictionary, or sequence of two-tuples.
+        content: *(optional)* Binary content to include in the body of the request, as bytes or a byte iterator.
+        data: *(optional)* Form data to include in the body of the request, as a dictionary.
+        files: *(optional)* A dictionary of upload files to include in the body of the request.
+        json: *(optional)* A JSON serializable object to include in the body of the request.
+        headers: *(optional)* Dictionary of HTTP headers to include in the request.
+        cookies: *(optional)* Dictionary of Cookie items to include in the request.
+        auth: *(optional)* An authentication class to use when sending the request.
+        proxy: *(optional)* A proxy URL where all the traffic should be routed.
+        timeout: *(optional)* The timeout configuration to use when sending the request.
+        follow_redirects: *(optional)* Enables or disables HTTP redirects.
+        verify: *(optional)* Either `True` to use an SSL context with the default CA bundle, `False` to disable
+            verification, or an instance of `ssl.SSLContext` to use a custom context.
+        trust_env: *(optional)* Enables or disables usage of environment variables for configuration.
+
+    Returns:
+        The `Response` object.
+
+    Usage:
+
+    ```
+    >>> import httpx2
+    >>> response = httpx2.request('GET', 'https://httpbin.org/get')
+    >>> response
+    <Response [200 OK]>
+    ```
+    """
+    with Client(
+        cookies=cookies,
+        proxy=proxy,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        return client.request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        )
+
+
+@contextmanager
+def stream(
+    method: str,
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> Generator[Response]:
+    """
+    Alternative to `httpx2.request()` that streams the response body
+    instead of loading it into memory at once.
+
+    **Parameters**: See `httpx2.request`.
+
+    See also: [Streaming Responses][0]
+
+    [0]: quickstart.md#streaming-responses
+    """
+    with Client(
+        cookies=cookies,
+        proxy=proxy,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        with client.stream(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+        ) as response:
+            yield response
+
+
+def get(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `GET` request.
+
+    **Parameters**: See `httpx2.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `GET` requests should not include a request body.
+    """
+    return request(
+        "GET",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def options(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends an `OPTIONS` request.
+
+    **Parameters**: See `httpx2.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `OPTIONS` requests should not include a request body.
+    """
+    return request(
+        "OPTIONS",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def head(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `HEAD` request.
+
+    **Parameters**: See `httpx2.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `HEAD` requests should not include a request body.
+    """
+    return request(
+        "HEAD",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def post(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `POST` request.
+
+    **Parameters**: See `httpx2.request`.
+    """
+    return request(
+        "POST",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def put(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PUT` request.
+
+    **Parameters**: See `httpx2.request`.
+    """
+    return request(
+        "PUT",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def patch(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `PATCH` request.
+
+    **Parameters**: See `httpx2.request`.
+    """
+    return request(
+        "PATCH",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def delete(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `DELETE` request.
+
+    **Parameters**: See `httpx2.request`.
+
+    Note that the `data`, `files`, `json` and `content` parameters are not available
+    on this function, as `DELETE` requests should not include a request body.
+    """
+    return request(
+        "DELETE",
+        url,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+def query(
+    url: URL | str,
+    *,
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: typing.Any | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    verify: ssl.SSLContext | str | bool = True,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    trust_env: bool = True,
+) -> Response:
+    """
+    Sends a `QUERY` request.
+
+    **Parameters**: See `httpx2.request`.
+    """
+    return request(
+        "QUERY",
+        url,
+        content=content,
+        data=data,
+        files=files,
+        json=json,
+        params=params,
+        headers=headers,
+        cookies=cookies,
+        auth=auth,
+        proxy=proxy,
+        follow_redirects=follow_redirects,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    )
+
+
+@contextmanager
+def websocket(
+    url: URL | str,
+    *,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | None = None,
+    proxy: ProxyTypes | None = None,
+    follow_redirects: bool = False,
+    timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+    verify: ssl.SSLContext | str | bool = True,
+    trust_env: bool = True,
+    subprotocols: list[str] | None = None,
+    max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    queue_size: int = DEFAULT_QUEUE_SIZE,
+    keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+) -> Generator[WebSocketSession]:
+    """
+    Open a WebSocket session.
+
+    The session is closed automatically when exiting the context manager.
+
+    ```python
+    with httpx2.websocket("ws://localhost:8000/ws") as ws:
+        ws.send_text("Hello!")
+        message = ws.receive_text()
+    ```
+
+    **Parameters**: See `httpx2.request` and `httpx2.Client.websocket`.
+    """
+    with Client(
+        cookies=cookies,
+        proxy=proxy,
+        verify=verify,
+        timeout=timeout,
+        trust_env=trust_env,
+    ) as client:
+        with client.websocket(
+            url,
+            params=params,
+            headers=headers,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            subprotocols=subprotocols,
+            max_message_size_bytes=max_message_size_bytes,
+            queue_size=queue_size,
+            keepalive_ping_interval_seconds=keepalive_ping_interval_seconds,
+            keepalive_ping_timeout_seconds=keepalive_ping_timeout_seconds,
+        ) as session:
+            yield session
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_auth.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_auth.py
new file mode 100644
index 0000000000000000000000000000000000000000..8418bf04c950d1adb15b56f27c1f7f4497fb6920
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_auth.py
@@ -0,0 +1,335 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import re
+import time
+import typing
+from base64 import b64encode
+from urllib.request import parse_http_list
+
+from ._exceptions import ProtocolError
+from ._models import Cookies, Request, Response
+from ._utils import to_bytes, to_str
+
+if typing.TYPE_CHECKING:
+    from collections.abc import Callable
+    from hashlib import _Hash
+
+__all__ = ["Auth", "BasicAuth", "DigestAuth", "FunctionAuth", "NetRCAuth"]
+
+
+class Auth:
+    """
+    Base class for all authentication schemes.
+
+    To implement a custom authentication scheme, subclass `Auth` and override
+    the `.auth_flow()` method.
+
+    If the authentication scheme does I/O such as disk access or network calls, or uses
+    synchronization primitives such as locks, you should override `.sync_auth_flow()`
+    and/or `.async_auth_flow()` instead of `.auth_flow()` to provide specialized
+    implementations that will be used by `Client` and `AsyncClient` respectively.
+    """
+
+    requires_request_body = False
+    requires_response_body = False
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow.
+
+        To dispatch a request, `yield` it:
+
+        ```
+        yield request
+        ```
+
+        The client will `.send()` the response back into the flow generator. You can
+        access it like so:
+
+        ```
+        response = yield request
+        ```
+
+        A `return` (or reaching the end of the generator) will result in the
+        client returning the last response obtained from the server.
+
+        You can dispatch as many requests as is necessary.
+        """
+        yield request
+
+    def sync_auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        """
+        Execute the authentication flow synchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            request.read()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                response.read()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+    async def async_auth_flow(self, request: Request) -> typing.AsyncGenerator[Request, Response]:
+        """
+        Execute the authentication flow asynchronously.
+
+        By default, this defers to `.auth_flow()`. You should override this method
+        when the authentication scheme does I/O and/or uses concurrency primitives.
+        """
+        if self.requires_request_body:
+            await request.aread()
+
+        flow = self.auth_flow(request)
+        request = next(flow)
+
+        while True:
+            response = yield request
+            if self.requires_response_body:
+                await response.aread()
+
+            try:
+                request = flow.send(response)
+            except StopIteration:
+                break
+
+
+class FunctionAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a simple callable function,
+    that takes the request, and returns a new, modified request.
+    """
+
+    def __init__(self, func: typing.Callable[[Request], Request]) -> None:
+        self._func = func
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        yield self._func(request)
+
+
+class BasicAuth(Auth):
+    """
+    Allows the 'auth' argument to be passed as a (username, password) pair,
+    and uses HTTP Basic authentication.
+    """
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        self._auth_header = self._build_auth_header(username, password)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        request.headers["Authorization"] = self._auth_header
+        yield request
+
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class NetRCAuth(Auth):
+    """
+    Use a 'netrc' file to lookup basic auth credentials based on the url host.
+    """
+
+    def __init__(self, file: str | None = None) -> None:
+        # Lazily import 'netrc'.
+        # There's no need for us to load this module unless 'NetRCAuth' is being used.
+        import netrc
+
+        self._netrc_info = netrc.netrc(file)
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        auth_info = self._netrc_info.authenticators(request.url.host)
+        if auth_info is None or not auth_info[2]:
+            # The netrc file did not have authentication credentials for this host.
+            yield request
+        else:
+            # Build a basic auth header with credentials from the netrc file.
+            request.headers["Authorization"] = self._build_auth_header(username=auth_info[0], password=auth_info[2])
+            yield request
+
+    def _build_auth_header(self, username: str | bytes, password: str | bytes) -> str:
+        userpass = b":".join((to_bytes(username), to_bytes(password)))
+        token = b64encode(userpass).decode()
+        return f"Basic {token}"
+
+
+class DigestAuth(Auth):
+    # Hashes are resolved by name at use time, since FIPS builds may remove or block MD5.
+    _ALGORITHM_TO_HASH_NAME = {
+        "MD5": "md5",
+        "MD5-SESS": "md5",
+        "SHA": "sha1",
+        "SHA-SESS": "sha1",
+        "SHA-256": "sha256",
+        "SHA-256-SESS": "sha256",
+        "SHA-512": "sha512",
+        "SHA-512-SESS": "sha512",
+    }
+
+    def __init__(self, username: str | bytes, password: str | bytes) -> None:
+        self._username = to_bytes(username)
+        self._password = to_bytes(password)
+        self._last_challenge: _DigestAuthChallenge | None = None
+        self._nonce_count = 1
+
+    def auth_flow(self, request: Request) -> typing.Generator[Request, Response, None]:
+        if self._last_challenge:
+            request.headers["Authorization"] = self._build_auth_header(request, self._last_challenge)
+
+        response = yield request
+
+        if response.status_code != 401 or "www-authenticate" not in response.headers:
+            # If the response is not a 401 then we don't
+            # need to build an authenticated request.
+            return
+
+        for auth_header in response.headers.get_list("www-authenticate"):
+            if auth_header.lower().startswith("digest "):
+                break
+        else:
+            # If the response does not include a 'WWW-Authenticate: Digest ...'
+            # header, then we don't need to build an authenticated request.
+            return
+
+        self._last_challenge = self._parse_challenge(request, response, auth_header)
+        self._nonce_count = 1
+
+        request.headers["Authorization"] = self._build_auth_header(request, self._last_challenge)
+        if response.cookies:
+            Cookies(response.cookies).set_cookie_header(request=request)
+        yield request
+
+    def _parse_challenge(self, request: Request, response: Response, auth_header: str) -> _DigestAuthChallenge:
+        """
+        Returns a challenge from a Digest WWW-Authenticate header.
+        These take the form of:
+        `Digest realm="realm@host.com",qop="auth,auth-int",nonce="abc",opaque="xyz"`
+        """
+        scheme, _, fields = auth_header.partition(" ")
+
+        # This method should only ever have been called with a Digest auth header.
+        assert scheme.lower() == "digest"
+
+        header_dict: dict[str, str] = {}
+        for field in parse_http_list(fields):
+            key, value = field.strip().split("=", 1)
+            header_dict[key] = value.strip('"')
+
+        try:
+            realm = header_dict["realm"].encode()
+            nonce = header_dict["nonce"].encode()
+            algorithm = header_dict.get("algorithm", "MD5")
+            opaque = header_dict["opaque"].encode() if "opaque" in header_dict else None
+            qop = header_dict["qop"].encode() if "qop" in header_dict else None
+            return _DigestAuthChallenge(realm=realm, nonce=nonce, algorithm=algorithm, opaque=opaque, qop=qop)
+        except KeyError as exc:
+            message = "Malformed Digest WWW-Authenticate header"
+            raise ProtocolError(message, request=request) from exc
+
+    def _build_auth_header(self, request: Request, challenge: _DigestAuthChallenge) -> str:
+        try:
+            hash_func: Callable[[bytes], _Hash] = getattr(
+                hashlib, self._ALGORITHM_TO_HASH_NAME[challenge.algorithm.upper()]
+            )
+        except (KeyError, AttributeError) as exc:
+            message = f"Unsupported digest auth algorithm {challenge.algorithm!r}"
+            raise ProtocolError(message, request=request) from exc
+
+        def digest(data: bytes) -> bytes:
+            return hash_func(data).hexdigest().encode()
+
+        A1 = b":".join((self._username, challenge.realm, self._password))
+
+        path = request.url.raw_path
+        A2 = b":".join((request.method.encode(), path))
+        # TODO: implement auth-int
+        HA2 = digest(A2)
+
+        nc_value = b"%08x" % self._nonce_count
+        cnonce = self._get_client_nonce(self._nonce_count, challenge.nonce)
+        self._nonce_count += 1
+
+        HA1 = digest(A1)
+        if challenge.algorithm.lower().endswith("-sess"):
+            HA1 = digest(b":".join((HA1, challenge.nonce, cnonce)))
+
+        qop = self._resolve_qop(challenge.qop, request=request)
+        if qop is None:
+            # Following RFC 2069
+            digest_data = [HA1, challenge.nonce, HA2]
+        else:
+            # Following RFC 2617/7616
+            digest_data = [HA1, challenge.nonce, nc_value, cnonce, qop, HA2]
+
+        format_args = {
+            "username": self._username,
+            "realm": challenge.realm,
+            "nonce": challenge.nonce,
+            "uri": path,
+            "response": digest(b":".join(digest_data)),
+            "algorithm": challenge.algorithm.encode(),
+        }
+        if challenge.opaque:
+            format_args["opaque"] = challenge.opaque
+        if qop:
+            format_args["qop"] = b"auth"
+            format_args["nc"] = nc_value
+            format_args["cnonce"] = cnonce
+
+        return "Digest " + self._get_header_value(format_args)
+
+    def _get_client_nonce(self, nonce_count: int, nonce: bytes) -> bytes:
+        s = str(nonce_count).encode()
+        s += nonce
+        s += time.ctime().encode()
+        s += os.urandom(8)
+
+        return hashlib.sha1(s).hexdigest()[:16].encode()
+
+    def _get_header_value(self, header_fields: dict[str, bytes]) -> str:
+        NON_QUOTED_FIELDS = ("algorithm", "qop", "nc")
+        QUOTED_TEMPLATE = '{}="{}"'
+        NON_QUOTED_TEMPLATE = "{}={}"
+
+        header_value = ""
+        for i, (field, value) in enumerate(header_fields.items()):
+            if i > 0:
+                header_value += ", "
+            template = QUOTED_TEMPLATE if field not in NON_QUOTED_FIELDS else NON_QUOTED_TEMPLATE
+            header_value += template.format(field, to_str(value))
+
+        return header_value
+
+    def _resolve_qop(self, qop: bytes | None, request: Request) -> bytes | None:
+        if qop is None:
+            return None
+        qops = re.split(b", ?", qop)
+        if b"auth" in qops:
+            return b"auth"
+
+        if qops == [b"auth-int"]:
+            raise NotImplementedError("Digest auth-int support is not yet implemented")
+
+        message = f'Unexpected qop value "{qop!r}" in digest auth'
+        raise ProtocolError(message, request=request)
+
+
+class _DigestAuthChallenge(typing.NamedTuple):
+    realm: bytes
+    nonce: bytes
+    algorithm: str
+    opaque: bytes | None
+    qop: bytes | None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_client.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..2103d36e3416d7c000a0fd5ec26c390b8beb6e91
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_client.py
@@ -0,0 +1,2237 @@
+from __future__ import annotations
+
+import datetime
+import enum
+import logging
+import time
+import typing
+import warnings
+from collections.abc import AsyncGenerator, Generator
+from contextlib import asynccontextmanager, contextmanager
+from types import TracebackType
+
+from .__version__ import __version__
+from ._auth import Auth, BasicAuth, FunctionAuth
+from ._config import (
+    DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+    DEFAULT_LIMITS,
+    DEFAULT_MAX_EVENT_SIZE_BYTES,
+    DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    DEFAULT_MAX_REDIRECTS,
+    DEFAULT_QUEUE_SIZE,
+    DEFAULT_TIMEOUT_CONFIG,
+    Limits,
+    Proxy,
+    Timeout,
+)
+from ._decoders import SUPPORTED_DECODERS
+from ._exceptions import (
+    InvalidURL,
+    RemoteProtocolError,
+    TooManyRedirects,
+    request_context,
+)
+from ._models import Cookies, Headers, Request, Response
+from ._sse import EventSource
+from ._status_codes import codes
+from ._transports import AsyncHTTPTransport, HTTPTransport
+from ._transports.base import AsyncBaseTransport, BaseTransport
+from ._types import (
+    AsyncByteStream,
+    AuthTypes,
+    CertTypes,
+    CookieTypes,
+    HeaderTypes,
+    ProxyTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestExtensions,
+    RequestFiles,
+    SyncByteStream,
+    TimeoutTypes,
+)
+from ._urls import URL, QueryParams
+from ._utils import URLPattern, get_environment_proxies
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+    from .websockets._api import AsyncWebSocketSession, WebSocketSession
+
+__all__ = ["USE_CLIENT_DEFAULT", "AsyncClient", "Client"]
+
+# The type annotation for @classmethod and context managers here follows PEP 484
+# https://www.python.org/dev/peps/pep-0484/#annotating-instance-and-class-methods
+T = typing.TypeVar("T", bound="Client")
+U = typing.TypeVar("U", bound="AsyncClient")
+
+
+def _is_https_redirect(url: URL, location: URL) -> bool:
+    """
+    Return 'True' if 'location' is a HTTPS upgrade of 'url'
+    """
+    origin = url.origin
+    location_origin = location.origin
+
+    return (
+        origin.host == location_origin.host
+        and origin.scheme == "http"
+        and origin.port == 80
+        and location_origin.scheme == "https"
+        and location_origin.port == 443
+    )
+
+
+class UseClientDefault:
+    """
+    For some parameters such as `auth=...` and `timeout=...` we need to be able
+    to indicate the default "unset" state, in a way that is distinctly different
+    to using `None`.
+
+    The default "unset" state indicates that whatever default is set on the
+    client should be used. This is different to setting `None`, which
+    explicitly disables the parameter, possibly overriding a client default.
+
+    For example we use `timeout=USE_CLIENT_DEFAULT` in the `request()` signature.
+    Omitting the `timeout` parameter will send a request using whatever default
+    timeout has been configured on the client. Including `timeout=None` will
+    ensure no timeout is used.
+
+    Note that user code shouldn't need to use the `USE_CLIENT_DEFAULT` constant,
+    but it is used internally when a parameter is not included.
+    """
+
+
+USE_CLIENT_DEFAULT = UseClientDefault()
+
+
+logger = logging.getLogger("httpx2")
+
+USER_AGENT = f"python-httpx2/{__version__}"
+ACCEPT_ENCODING = ", ".join([key for key in SUPPORTED_DECODERS.keys() if key != "identity"])
+
+
+class ClientState(enum.Enum):
+    # UNOPENED:
+    #   The client has been instantiated, but has not been used to send a request,
+    #   or been opened by entering the context of a `with` block.
+    UNOPENED = 1
+    # OPENED:
+    #   The client has either sent a request, or is within a `with` block.
+    OPENED = 2
+    # CLOSED:
+    #   The client has either exited the `with` block, or `close()` has
+    #   been called explicitly.
+    CLOSED = 3
+
+
+class BoundSyncStream(SyncByteStream):
+    """
+    A byte stream that tracks elapsed time for a response. Once closed, the
+    elapsed time is available via the `elapsed` attribute, and the response
+    can read it back from `response.stream.elapsed`.
+    """
+
+    def __init__(self, stream: SyncByteStream, start: float) -> None:
+        self._stream = stream
+        self._start = start
+        self.elapsed: datetime.timedelta | None = None
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        yield from self._stream
+
+    def close(self) -> None:
+        self.elapsed = datetime.timedelta(seconds=time.perf_counter() - self._start)
+        self._stream.close()
+
+
+class BoundAsyncStream(AsyncByteStream):
+    """
+    An async byte stream that tracks elapsed time for a response. Once closed,
+    the elapsed time is available via the `elapsed` attribute, and the response
+    can read it back from `response.stream.elapsed`.
+    """
+
+    def __init__(self, stream: AsyncByteStream, start: float) -> None:
+        self._stream = stream
+        self._start = start
+        self.elapsed: datetime.timedelta | None = None
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        stream = self._stream.__aiter__()
+        try:
+            async for chunk in stream:
+                yield chunk
+        finally:
+            if isinstance(stream, AsyncGenerator):
+                await stream.aclose()
+
+    async def aclose(self) -> None:
+        self.elapsed = datetime.timedelta(seconds=time.perf_counter() - self._start)
+        await self._stream.aclose()
+
+
+EventHook = typing.Callable[..., typing.Any]
+
+
+class BaseClient:
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        trust_env: bool = True,
+        default_encoding: str | typing.Callable[[bytes], str | None] = "utf-8",
+    ) -> None:
+        event_hooks = {} if event_hooks is None else event_hooks
+
+        self._base_url = self._enforce_trailing_slash(URL(base_url))
+
+        self._auth = self._build_auth(auth)
+        self._params = QueryParams(params)
+        self.headers = Headers(headers)
+        self._cookies = Cookies(cookies)
+        self._timeout = Timeout(timeout)
+        self.follow_redirects = follow_redirects
+        self.max_redirects = max_redirects
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+        self._trust_env = trust_env
+        self._default_encoding = default_encoding
+        self._state = ClientState.UNOPENED
+
+    @property
+    def is_closed(self) -> bool:
+        """
+        Check if the client being closed
+        """
+        return self._state == ClientState.CLOSED
+
+    @property
+    def trust_env(self) -> bool:
+        return self._trust_env
+
+    def _enforce_trailing_slash(self, url: URL) -> URL:
+        if url.raw_path.endswith(b"/"):
+            return url
+        return url.copy_with(raw_path=url.raw_path + b"/")
+
+    def _get_proxy_map(self, proxy: ProxyTypes | None, allow_env_proxies: bool) -> dict[str, Proxy | None]:
+        if proxy is None:
+            if allow_env_proxies:
+                return {key: None if url is None else Proxy(url=url) for key, url in get_environment_proxies().items()}
+            return {}
+        else:
+            proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+            return {"all://": proxy}
+
+    @property
+    def timeout(self) -> Timeout:
+        return self._timeout
+
+    @timeout.setter
+    def timeout(self, timeout: TimeoutTypes) -> None:
+        self._timeout = Timeout(timeout)
+
+    @property
+    def event_hooks(self) -> dict[str, list[EventHook]]:
+        return self._event_hooks
+
+    @event_hooks.setter
+    def event_hooks(self, event_hooks: dict[str, list[EventHook]]) -> None:
+        self._event_hooks = {
+            "request": list(event_hooks.get("request", [])),
+            "response": list(event_hooks.get("response", [])),
+        }
+
+    @property
+    def auth(self) -> Auth | None:
+        """
+        Authentication class used when none is passed at the request-level.
+
+        See also [Authentication][0].
+
+        [0]: quickstart.md#authentication
+        """
+        return self._auth
+
+    @auth.setter
+    def auth(self, auth: AuthTypes) -> None:
+        self._auth = self._build_auth(auth)
+
+    @property
+    def base_url(self) -> URL:
+        """
+        Base URL to use when sending requests with relative URLs.
+        """
+        return self._base_url
+
+    @base_url.setter
+    def base_url(self, url: URL | str) -> None:
+        self._base_url = self._enforce_trailing_slash(URL(url))
+
+    @property
+    def headers(self) -> Headers:
+        """
+        HTTP headers to include when sending requests.
+        """
+        return self._headers
+
+    @headers.setter
+    def headers(self, headers: HeaderTypes) -> None:
+        client_headers = Headers(
+            {
+                b"Accept": b"*/*",
+                b"Accept-Encoding": ACCEPT_ENCODING.encode("ascii"),
+                b"Connection": b"keep-alive",
+                b"User-Agent": USER_AGENT.encode("ascii"),
+            }
+        )
+        client_headers.update(headers)
+        self._headers = client_headers
+
+    @property
+    def cookies(self) -> Cookies:
+        """
+        Cookie values to include when sending requests.
+        """
+        return self._cookies
+
+    @cookies.setter
+    def cookies(self, cookies: CookieTypes) -> None:
+        self._cookies = Cookies(cookies)
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        Query parameters to include in the URL when sending requests.
+        """
+        return self._params
+
+    @params.setter
+    def params(self, params: QueryParamTypes) -> None:
+        self._params = QueryParams(params)
+
+    def build_request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Request:
+        """
+        Build and return a request instance.
+
+        * The `params`, `headers` and `cookies` arguments
+        are merged with any values set on the client.
+        * The `url` argument is merged with any `base_url` set on the client.
+
+        See also: [Request instances][0]
+
+        [0]: advanced/clients.md#request-instances
+        """
+        url = self._merge_url(url)
+        headers = self._merge_headers(headers)
+        cookies = self._merge_cookies(cookies)
+        params = self._merge_queryparams(params)
+        extensions = {} if extensions is None else extensions
+        if "timeout" not in extensions:
+            timeout = self.timeout if isinstance(timeout, UseClientDefault) else Timeout(timeout)
+            extensions = dict(**extensions, timeout=timeout.as_dict())
+        return Request(
+            method,
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            extensions=extensions,
+        )
+
+    def _merge_url(self, url: URL | str) -> URL:
+        """
+        Merge a URL argument together with any 'base_url' on the client,
+        to create the URL used for the outgoing request.
+        """
+        merge_url = URL(url)
+        if merge_url.is_relative_url:
+            # To merge URLs we always append to the base URL. To get this
+            # behaviour correct we always ensure the base URL ends in a '/'
+            # separator, and strip any leading '/' from the merge URL.
+            #
+            # So, eg...
+            #
+            # >>> client = Client(base_url="https://www.example.com/subpath")
+            # >>> client.base_url
+            # URL('https://www.example.com/subpath/')
+            # >>> client.build_request("GET", "/path").url
+            # URL('https://www.example.com/subpath/path')
+            merge_raw_path = self.base_url.raw_path + merge_url.raw_path.lstrip(b"/")
+            return self.base_url.copy_with(raw_path=merge_raw_path)
+        return merge_url
+
+    def _merge_cookies(self, cookies: CookieTypes | None = None) -> CookieTypes | None:
+        """
+        Merge a cookies argument together with any cookies on the client,
+        to create the cookies used for the outgoing request.
+        """
+        if cookies or self.cookies:
+            merged_cookies = Cookies(self.cookies)
+            merged_cookies.update(cookies)
+            return merged_cookies
+        return cookies
+
+    def _merge_headers(self, headers: HeaderTypes | None = None) -> HeaderTypes | None:
+        """
+        Merge a headers argument together with any headers on the client,
+        to create the headers used for the outgoing request.
+        """
+        merged_headers = Headers(self.headers)
+        merged_headers.update(headers)
+        return merged_headers
+
+    def _merge_queryparams(self, params: QueryParamTypes | None = None) -> QueryParamTypes | None:
+        """
+        Merge a queryparams argument together with any queryparams on the client,
+        to create the queryparams used for the outgoing request.
+        """
+        if params or self.params:
+            merged_queryparams = QueryParams(self.params)
+            return merged_queryparams.merge(params)
+        return params
+
+    def _build_auth(self, auth: AuthTypes | None) -> Auth | None:
+        if auth is None:
+            return None
+        elif isinstance(auth, tuple):
+            return BasicAuth(username=auth[0], password=auth[1])
+        elif isinstance(auth, Auth):
+            return auth
+        elif callable(auth):
+            return FunctionAuth(func=auth)
+        else:
+            raise TypeError(f'Invalid "auth" argument: {auth!r}')
+
+    def _build_request_auth(
+        self,
+        request: Request,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+    ) -> Auth:
+        auth = self._auth if isinstance(auth, UseClientDefault) else self._build_auth(auth)
+
+        if auth is not None:
+            return auth
+
+        username, password = request.url.username, request.url.password
+        if username or password:
+            return BasicAuth(username=username, password=password)
+
+        return Auth()
+
+    def _build_redirect_request(self, request: Request, response: Response) -> Request:
+        """
+        Given a request and a redirect response, return a new request that
+        should be used to effect the redirect.
+        """
+        method = self._redirect_method(request, response)
+        url = self._redirect_url(request, response)
+        headers = self._redirect_headers(request, url, method)
+        stream = self._redirect_stream(request, method)
+        cookies = Cookies(self.cookies)
+        return Request(
+            method=method,
+            url=url,
+            headers=headers,
+            cookies=cookies,
+            stream=stream,
+            extensions=request.extensions,
+        )
+
+    def _redirect_method(self, request: Request, response: Response) -> str:
+        """
+        When being redirected we may want to change the method of the request
+        based on certain specs or browser behavior.
+        """
+        method = request.method
+
+        # https://tools.ietf.org/html/rfc7231#section-6.4.4
+        if response.status_code == codes.SEE_OTHER and method != "HEAD":
+            method = "GET"
+
+        # Do what the browsers do, despite standards...
+        # Turn 302s into GETs.
+        # QUERY is excluded, per RFC 10008 Section 2.5.
+        # https://datatracker.ietf.org/doc/html/rfc10008#section-2.5
+        if response.status_code == codes.FOUND and method not in ("HEAD", "QUERY"):
+            method = "GET"
+
+        # If a POST is responded to with a 301, turn it into a GET.
+        # This bizarre behaviour is explained in 'requests' issue 1704.
+        if response.status_code == codes.MOVED_PERMANENTLY and method == "POST":
+            method = "GET"
+
+        return method
+
+    def _redirect_url(self, request: Request, response: Response) -> URL:
+        """
+        Return the URL for the redirect to follow.
+        """
+        location = response.headers["Location"]
+
+        try:
+            url = URL(location)
+        except InvalidURL as exc:
+            raise RemoteProtocolError(f"Invalid URL in location header: {exc}.", request=request) from None
+
+        # Handle malformed 'Location' headers that are "absolute" form, have no host.
+        # See: https://github.com/encode/httpx/issues/771
+        if url.scheme and not url.host:
+            url = url.copy_with(host=request.url.host)
+
+        # Facilitate relative 'Location' headers, as allowed by RFC 7231.
+        # (e.g. '/path/to/resource' instead of 'http://domain.tld/path/to/resource')
+        if url.is_relative_url:
+            url = request.url.join(url)
+
+        # Attach previous fragment if needed (RFC 7231 7.1.2)
+        if request.url.fragment and not url.fragment:
+            url = url.copy_with(fragment=request.url.fragment)
+
+        return url
+
+    def _redirect_headers(self, request: Request, url: URL, method: str) -> Headers:
+        """
+        Return the headers that should be used for the redirect request.
+        """
+        headers = Headers(request.headers)
+
+        if url.origin != request.url.origin:
+            if not _is_https_redirect(request.url, url):
+                # Strip Authorization headers when responses are redirected
+                # away from the origin. (Except for direct HTTP to HTTPS redirects.)
+                headers.pop("Authorization", None)
+
+            # Update the Host header.
+            headers["Host"] = url.netloc.decode("ascii")
+
+        if method != request.method and method == "GET":
+            # If we've switch to a 'GET' request, then strip any headers which
+            # are only relevant to the request body.
+            headers.pop("Content-Length", None)
+            headers.pop("Transfer-Encoding", None)
+
+        # We should use the client cookie store to determine any cookie header,
+        # rather than whatever was on the original outgoing request.
+        headers.pop("Cookie", None)
+
+        return headers
+
+    def _redirect_stream(self, request: Request, method: str) -> SyncByteStream | AsyncByteStream | None:
+        """
+        Return the body that should be used for the redirect request.
+        """
+        if method != request.method and method == "GET":
+            return None
+
+        return request.stream
+
+    def _set_timeout(self, request: Request) -> None:
+        if "timeout" not in request.extensions:
+            timeout = self.timeout if isinstance(self.timeout, UseClientDefault) else Timeout(self.timeout)
+            request.extensions = dict(**request.extensions, timeout=timeout.as_dict())
+
+
+class Client(BaseClient):
+    """
+    An HTTP client, with connection pooling, HTTP/2, redirects, cookie persistence, etc.
+
+    It can be shared between threads.
+
+    Usage:
+
+    ```python
+    >>> client = httpx2.Client()
+    >>> response = client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **mounts** - *(optional)* A dictionary mapping URL patterns to transports,
+    used to route requests through specific transports based on the URL.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, BaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        transport: BaseTransport | None = None,
+        default_encoding: str | typing.Callable[[bytes], str | None] = "utf-8",
+    ) -> None:
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and transport is None
+        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+        )
+        self._mounts: dict[URLPattern, BaseTransport | None] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                trust_env=trust_env,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update({URLPattern(key): transport for key, transport in mounts.items()})
+
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: BaseTransport | None = None,
+    ) -> BaseTransport:
+        if transport is not None:
+            return transport
+
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+    ) -> BaseTransport:
+        return HTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> BaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    def request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = client.send(request, ...)
+        ```
+
+        See `Client.build_request()`, `Client.send()` and
+        [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: advanced/clients.md#merging-of-configuration
+        """
+        if cookies is not None:
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @contextmanager
+    def stream(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Generator[Response]:
+        """
+        Alternative to `httpx2.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx2.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: quickstart.md#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            response.close()
+
+    @contextmanager
+    def sse(
+        self,
+        url: URL | str,
+        *,
+        method: str = "GET",
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+        max_event_size: int | None = DEFAULT_MAX_EVENT_SIZE_BYTES,
+    ) -> Generator[EventSource]:
+        """
+        Connect to a server-sent events endpoint and yield an `EventSource`.
+
+        Iterating the `EventSource` yields `ServerSentEvent` instances.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        with self.stream(
+            method,
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers={"Accept": "text/event-stream", "Cache-Control": "no-store"} | Headers(headers),
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as response:
+            yield EventSource(response, max_event_size=max_event_size)
+
+    @contextmanager
+    def websocket(
+        self,
+        url: URL | str,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        subprotocols: list[str] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Generator[WebSocketSession]:
+        """
+        Open a WebSocket session, using this client's configuration.
+
+        The session is closed automatically when exiting the context manager.
+
+        ```python
+        with httpx2.Client() as client:
+            with client.websocket("ws://localhost:8000/ws") as ws:
+                ws.send_text("Hello!")
+                message = ws.receive_text()
+        ```
+        """
+        try:
+            from .websockets._api import connect_ws
+        except ImportError:  # pragma: no cover
+            raise ImportError(
+                "WebSocket support requires the `wsproto` package. Install it with `pip install httpx2[ws]`."
+            )
+
+        with connect_ws(
+            str(url),
+            self,
+            max_message_size_bytes=max_message_size_bytes,
+            queue_size=queue_size,
+            keepalive_ping_interval_seconds=keepalive_ping_interval_seconds,
+            keepalive_ping_timeout_seconds=keepalive_ping_timeout_seconds,
+            subprotocols=subprotocols,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as session:
+            yield session
+
+    def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `Client.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx2.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: advanced/clients.md#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = self.follow_redirects if isinstance(follow_redirects, UseClientDefault) else follow_redirects
+
+        self._set_timeout(request)
+
+        auth = self._build_request_auth(request, auth)
+
+        response = self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                response.read()
+
+            return response
+
+        except BaseException as exc:
+            response.close()
+            raise exc
+
+    def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        auth_flow = auth.sync_auth_flow(request)
+        try:
+            request = next(auth_flow)
+
+            while True:
+                response = self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = auth_flow.send(response)
+                    except StopIteration:
+                        return response
+
+                    response.history = list(history)
+                    response.read()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    response.close()
+                    raise exc
+        finally:
+            auth_flow.close()
+
+    def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects("Exceeded maximum allowed redirects.", request=request)
+
+            for hook in self._event_hooks["request"]:
+                hook(request)
+
+            response = self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    hook(response)
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    response.read()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                response.close()
+                raise exc
+
+    def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        start = time.perf_counter()
+
+        if not isinstance(request.stream, SyncByteStream):
+            raise RuntimeError("Attempted to send an async request with a sync Client instance.")
+
+        with request_context(request=request):
+            response = transport.handle_request(request)
+
+        assert isinstance(response.stream, SyncByteStream)
+
+        response.request = request
+        response.stream = BoundSyncStream(response.stream, start=start)
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
+
+        return response
+
+    def get(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def options(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def head(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def post(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def put(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def patch(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def delete(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def query(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `QUERY` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return self.request(
+            "QUERY",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    def close(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            self._transport.close()
+            for transport in self._mounts.values():
+                if transport is not None:
+                    transport.close()
+
+    def __enter__(self: T) -> T:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: ("Cannot reopen a client instance, once it has been closed."),
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        self._transport.__enter__()
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        self._transport.__exit__(exc_type, exc_value, traceback)
+        for transport in self._mounts.values():
+            if transport is not None:
+                transport.__exit__(exc_type, exc_value, traceback)
+
+
+class AsyncClient(BaseClient):
+    """
+    An asynchronous HTTP client, with connection pooling, HTTP/2, redirects,
+    cookie persistence, etc.
+
+    It can be shared between tasks.
+
+    Usage:
+
+    ```python
+    >>> async with httpx2.AsyncClient() as client:
+    >>>     response = await client.get('https://example.org')
+    ```
+
+    **Parameters:**
+
+    * **auth** - *(optional)* An authentication class to use when sending
+    requests.
+    * **params** - *(optional)* Query parameters to include in request URLs, as
+    a string, dictionary, or sequence of two-tuples.
+    * **headers** - *(optional)* Dictionary of HTTP headers to include when
+    sending requests.
+    * **cookies** - *(optional)* Dictionary of Cookie items to include when
+    sending requests.
+    * **verify** - *(optional)* Either `True` to use an SSL context with the
+    default CA bundle, `False` to disable verification, or an instance of
+    `ssl.SSLContext` to use a custom context.
+    * **http2** - *(optional)* A boolean indicating if HTTP/2 support should be
+    enabled. Defaults to `False`.
+    * **proxy** - *(optional)* A proxy URL where all the traffic should be routed.
+    * **mounts** - *(optional)* A dictionary mapping URL patterns to transports,
+    used to route requests through specific transports based on the URL.
+    * **timeout** - *(optional)* The timeout configuration to use when sending
+    requests.
+    * **limits** - *(optional)* The limits configuration to use.
+    * **max_redirects** - *(optional)* The maximum number of redirect responses
+    that should be followed.
+    * **base_url** - *(optional)* A URL to use as the base when building
+    request URLs.
+    * **transport** - *(optional)* A transport class to use for sending requests
+    over the network.
+    * **trust_env** - *(optional)* Enables or disables usage of environment
+    variables for configuration.
+    * **default_encoding** - *(optional)* The default encoding to use for decoding
+    response text, if no charset information is included in a response Content-Type
+    header. Set to a callable for automatic character set detection. Default: "utf-8".
+    """
+
+    def __init__(
+        self,
+        *,
+        auth: AuthTypes | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        http1: bool = True,
+        http2: bool = False,
+        proxy: ProxyTypes | None = None,
+        mounts: None | (typing.Mapping[str, AsyncBaseTransport | None]) = None,
+        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        follow_redirects: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        max_redirects: int = DEFAULT_MAX_REDIRECTS,
+        event_hooks: None | (typing.Mapping[str, list[EventHook]]) = None,
+        base_url: URL | str = "",
+        transport: AsyncBaseTransport | None = None,
+        trust_env: bool = True,
+        default_encoding: str | typing.Callable[[bytes], str | None] = "utf-8",
+    ) -> None:
+        super().__init__(
+            auth=auth,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            follow_redirects=follow_redirects,
+            max_redirects=max_redirects,
+            event_hooks=event_hooks,
+            base_url=base_url,
+            trust_env=trust_env,
+            default_encoding=default_encoding,
+        )
+
+        if http2:
+            try:
+                import h2  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using http2=True, but the 'h2' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[http2]`."
+                ) from None
+
+        allow_env_proxies = trust_env and transport is None
+        proxy_map = self._get_proxy_map(proxy, allow_env_proxies)
+
+        self._transport = self._init_transport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            transport=transport,
+        )
+
+        self._mounts: dict[URLPattern, AsyncBaseTransport | None] = {
+            URLPattern(key): None
+            if proxy is None
+            else self._init_proxy_transport(
+                proxy,
+                verify=verify,
+                cert=cert,
+                trust_env=trust_env,
+                http1=http1,
+                http2=http2,
+                limits=limits,
+            )
+            for key, proxy in proxy_map.items()
+        }
+        if mounts is not None:
+            self._mounts.update({URLPattern(key): transport for key, transport in mounts.items()})
+        self._mounts = dict(sorted(self._mounts.items()))
+
+    def _init_transport(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        transport: AsyncBaseTransport | None = None,
+    ) -> AsyncBaseTransport:
+        if transport is not None:
+            return transport
+
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+        )
+
+    def _init_proxy_transport(
+        self,
+        proxy: Proxy,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+    ) -> AsyncBaseTransport:
+        return AsyncHTTPTransport(
+            verify=verify,
+            cert=cert,
+            trust_env=trust_env,
+            http1=http1,
+            http2=http2,
+            limits=limits,
+            proxy=proxy,
+        )
+
+    def _transport_for_url(self, url: URL) -> AsyncBaseTransport:
+        """
+        Returns the transport instance that should be used for a given URL.
+        This will either be the standard connection pool, or a proxy.
+        """
+        for pattern, transport in self._mounts.items():
+            if pattern.matches(url):
+                return self._transport if transport is None else transport
+
+        return self._transport
+
+    async def request(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Build and send a request.
+
+        Equivalent to:
+
+        ```python
+        request = client.build_request(...)
+        response = await client.send(request, ...)
+        ```
+
+        See `AsyncClient.build_request()`, `AsyncClient.send()`
+        and [Merging of configuration][0] for how the various parameters
+        are merged with client-level configuration.
+
+        [0]: advanced/clients.md#merging-of-configuration
+        """
+
+        if cookies is not None:  # pragma: no cover
+            message = (
+                "Setting per-request cookies=<...> is being deprecated, because "
+                "the expected behaviour on cookie persistence is ambiguous. Set "
+                "cookies directly on the client instance instead."
+            )
+            warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        return await self.send(request, auth=auth, follow_redirects=follow_redirects)
+
+    @asynccontextmanager
+    async def stream(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> AsyncGenerator[Response]:
+        """
+        Alternative to `httpx2.request()` that streams the response body
+        instead of loading it into memory at once.
+
+        **Parameters**: See `httpx2.request`.
+
+        See also: [Streaming Responses][0]
+
+        [0]: quickstart.md#streaming-responses
+        """
+        request = self.build_request(
+            method=method,
+            url=url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            timeout=timeout,
+            extensions=extensions,
+        )
+        response = await self.send(
+            request=request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            stream=True,
+        )
+        try:
+            yield response
+        finally:
+            await response.aclose()
+
+    @asynccontextmanager
+    async def sse(
+        self,
+        url: URL | str,
+        *,
+        method: str = "GET",
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+        max_event_size: int | None = DEFAULT_MAX_EVENT_SIZE_BYTES,
+    ) -> AsyncGenerator[EventSource]:
+        """
+        Connect to a server-sent events endpoint and yield an `EventSource`.
+
+        Iterating the `EventSource` yields `ServerSentEvent` instances.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        async with self.stream(
+            method,
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers={"Accept": "text/event-stream", "Cache-Control": "no-store"} | Headers(headers),
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as response:
+            yield EventSource(response, max_event_size=max_event_size)
+
+    @asynccontextmanager
+    async def websocket(
+        self,
+        url: URL | str,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        subprotocols: list[str] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> AsyncGenerator[AsyncWebSocketSession]:
+        """
+        Open a WebSocket session, using this client's configuration.
+
+        The session is closed automatically when exiting the context manager.
+
+        ```python
+        async with httpx2.AsyncClient() as client:
+            async with client.websocket("ws://localhost:8000/ws") as ws:
+                await ws.send_text("Hello!")
+                message = await ws.receive_text()
+        ```
+        """
+        try:
+            from .websockets._api import aconnect_ws
+        except ImportError:  # pragma: no cover
+            raise ImportError(
+                "WebSocket support requires the `wsproto` package. Install it with `pip install httpx2[ws]`."
+            )
+
+        async with aconnect_ws(
+            str(url),
+            self,
+            max_message_size_bytes=max_message_size_bytes,
+            queue_size=queue_size,
+            keepalive_ping_interval_seconds=keepalive_ping_interval_seconds,
+            keepalive_ping_timeout_seconds=keepalive_ping_timeout_seconds,
+            subprotocols=subprotocols,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as session:
+            yield session
+
+    async def send(
+        self,
+        request: Request,
+        *,
+        stream: bool = False,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    ) -> Response:
+        """
+        Send a request.
+
+        The request is sent as-is, unmodified.
+
+        Typically you'll want to build one with `AsyncClient.build_request()`
+        so that any client-level configuration is merged into the request,
+        but passing an explicit `httpx2.Request()` is supported as well.
+
+        See also: [Request instances][0]
+
+        [0]: advanced/clients.md#request-instances
+        """
+        if self._state == ClientState.CLOSED:
+            raise RuntimeError("Cannot send a request, as the client has been closed.")
+
+        self._state = ClientState.OPENED
+        follow_redirects = self.follow_redirects if isinstance(follow_redirects, UseClientDefault) else follow_redirects
+
+        self._set_timeout(request)
+
+        auth = self._build_request_auth(request, auth)
+
+        response = await self._send_handling_auth(
+            request,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            history=[],
+        )
+        try:
+            if not stream:
+                await response.aread()
+
+            return response
+
+        except BaseException as exc:
+            await response.aclose()
+            raise exc
+
+    async def _send_handling_auth(
+        self,
+        request: Request,
+        auth: Auth,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        auth_flow = auth.async_auth_flow(request)
+        try:
+            request = await auth_flow.__anext__()
+
+            while True:
+                response = await self._send_handling_redirects(
+                    request,
+                    follow_redirects=follow_redirects,
+                    history=history,
+                )
+                try:
+                    try:
+                        next_request = await auth_flow.asend(response)
+                    except StopAsyncIteration:
+                        return response
+
+                    response.history = list(history)
+                    await response.aread()
+                    request = next_request
+                    history.append(response)
+
+                except BaseException as exc:
+                    await response.aclose()
+                    raise exc
+        finally:
+            await auth_flow.aclose()
+
+    async def _send_handling_redirects(
+        self,
+        request: Request,
+        follow_redirects: bool,
+        history: list[Response],
+    ) -> Response:
+        while True:
+            if len(history) > self.max_redirects:
+                raise TooManyRedirects("Exceeded maximum allowed redirects.", request=request)
+
+            for hook in self._event_hooks["request"]:
+                await hook(request)
+
+            response = await self._send_single_request(request)
+            try:
+                for hook in self._event_hooks["response"]:
+                    await hook(response)
+
+                response.history = list(history)
+
+                if not response.has_redirect_location:
+                    return response
+
+                request = self._build_redirect_request(request, response)
+                history = history + [response]
+
+                if follow_redirects:
+                    await response.aread()
+                else:
+                    response.next_request = request
+                    return response
+
+            except BaseException as exc:
+                await response.aclose()
+                raise exc
+
+    async def _send_single_request(self, request: Request) -> Response:
+        """
+        Sends a single request, without handling any redirections.
+        """
+        transport = self._transport_for_url(request.url)
+        start = time.perf_counter()
+
+        if not isinstance(request.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to send a sync request with an AsyncClient instance.")
+
+        with request_context(request=request):
+            response = await transport.handle_async_request(request)
+
+        assert isinstance(response.stream, AsyncByteStream)
+        response.request = request
+        response.stream = BoundAsyncStream(response.stream, start=start)
+        self.cookies.extract_cookies(response)
+        response.default_encoding = self._default_encoding
+
+        logger.info(
+            'HTTP Request: %s %s "%s %d %s"',
+            request.method,
+            request.url,
+            response.http_version,
+            response.status_code,
+            response.reason_phrase,
+        )
+
+        return response
+
+    async def get(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `GET` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "GET",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def options(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send an `OPTIONS` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "OPTIONS",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def head(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `HEAD` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "HEAD",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def post(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `POST` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "POST",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def put(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PUT` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "PUT",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def patch(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `PATCH` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "PATCH",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def delete(
+        self,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `DELETE` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "DELETE",
+            url,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def query(
+        self,
+        url: URL | str,
+        *,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> Response:
+        """
+        Send a `QUERY` request.
+
+        **Parameters**: See `httpx2.request`.
+        """
+        return await self.request(
+            "QUERY",
+            url,
+            content=content,
+            data=data,
+            files=files,
+            json=json,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        )
+
+    async def aclose(self) -> None:
+        """
+        Close transport and proxies.
+        """
+        if self._state != ClientState.CLOSED:
+            self._state = ClientState.CLOSED
+
+            await self._transport.aclose()
+            for proxy in self._mounts.values():
+                if proxy is not None:
+                    await proxy.aclose()
+
+    async def __aenter__(self: U) -> U:
+        if self._state != ClientState.UNOPENED:
+            msg = {
+                ClientState.OPENED: "Cannot open a client instance more than once.",
+                ClientState.CLOSED: ("Cannot reopen a client instance, once it has been closed."),
+            }[self._state]
+            raise RuntimeError(msg)
+
+        self._state = ClientState.OPENED
+
+        await self._transport.__aenter__()
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self._state = ClientState.CLOSED
+
+        await self._transport.__aexit__(exc_type, exc_value, traceback)
+        for proxy in self._mounts.values():
+            if proxy is not None:
+                await proxy.__aexit__(exc_type, exc_value, traceback)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_config.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..b533707b1c3109ea6db277deeda40c144a4d9c5a
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_config.py
@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import dataclasses
+import os
+import typing
+
+from ._models import Headers
+from ._types import CertTypes, HeaderTypes, TimeoutTypes
+from ._urls import URL
+
+if typing.TYPE_CHECKING:
+    import ssl  # pragma: no cover
+
+__all__ = ["Limits", "Proxy", "Timeout", "create_ssl_context"]
+
+
+class UnsetType:
+    pass  # pragma: no cover
+
+
+UNSET = UnsetType()
+
+
+def create_ssl_context(
+    verify: ssl.SSLContext | str | bool = True,
+    cert: CertTypes | None = None,
+    trust_env: bool = True,
+) -> ssl.SSLContext:
+    import ssl
+    import warnings
+
+    import httpcore2
+
+    if verify is True:
+        ctx = httpcore2.default_ssl_context(_trust_env=trust_env)
+    elif verify is False:
+        ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    elif isinstance(verify, str):
+        if cert:
+            raise TypeError(
+                "`verify=<str>` cannot be combined with `cert=...`. "
+                "Build an `ssl.SSLContext` and pass it as `verify=<ctx>`, "
+                "using `.load_cert_chain()` to configure the certificate chain."
+            )
+        message = (
+            "`verify=<str>` is deprecated. "
+            "Use `verify=ssl.create_default_context(cafile=...)` "
+            "or `verify=ssl.create_default_context(capath=...)` instead."
+        )
+        warnings.warn(message, DeprecationWarning)
+        if os.path.isdir(verify):  # pragma: no cover
+            return ssl.create_default_context(capath=verify)
+        return ssl.create_default_context(cafile=verify)
+    else:
+        ctx = verify
+
+    if cert:  # pragma: no cover
+        message = (
+            "`cert=...` is deprecated. Use `verify=<ssl_context>` instead,"
+            "with `.load_cert_chain()` to configure the certificate chain."
+        )
+        warnings.warn(message, DeprecationWarning)
+        if isinstance(cert, str):
+            ctx.load_cert_chain(cert)
+        else:
+            ctx.load_cert_chain(*cert)
+
+    return ctx
+
+
+@dataclasses.dataclass(init=False, repr=False)
+class Timeout:
+    """
+    Timeout configuration.
+
+    **Usage**:
+
+    Timeout(None)               # No timeouts.
+    Timeout(5.0)                # 5s timeout on all operations.
+    Timeout(None, connect=5.0)  # 5s timeout on connect, no other timeouts.
+    Timeout(5.0, connect=10.0)  # 10s timeout on connect. 5s timeout elsewhere.
+    Timeout(5.0, pool=None)     # No timeout on acquiring connection from pool.
+                                # 5s timeout elsewhere.
+    """
+
+    connect: float | None
+    read: float | None
+    write: float | None
+    pool: float | None
+
+    def __init__(
+        self,
+        timeout: TimeoutTypes | UnsetType = UNSET,
+        *,
+        connect: None | float | UnsetType = UNSET,
+        read: None | float | UnsetType = UNSET,
+        write: None | float | UnsetType = UNSET,
+        pool: None | float | UnsetType = UNSET,
+    ) -> None:
+        if isinstance(timeout, Timeout):
+            # Passed as a single explicit Timeout.
+            assert connect is UNSET
+            assert read is UNSET
+            assert write is UNSET
+            assert pool is UNSET
+            self.connect = timeout.connect
+            self.read = timeout.read
+            self.write = timeout.write
+            self.pool = timeout.pool
+        elif isinstance(timeout, tuple):
+            # Passed as a tuple.
+            self.connect = timeout[0]
+            self.read = timeout[1]
+            self.write = None if len(timeout) < 3 else timeout[2]
+            self.pool = None if len(timeout) < 4 else timeout[3]
+        elif not (
+            isinstance(connect, UnsetType)
+            or isinstance(read, UnsetType)
+            or isinstance(write, UnsetType)
+            or isinstance(pool, UnsetType)
+        ):
+            self.connect = connect
+            self.read = read
+            self.write = write
+            self.pool = pool
+        else:
+            if isinstance(timeout, UnsetType):
+                raise ValueError("httpx2.Timeout must either include a default, or set all four parameters explicitly.")
+            self.connect = timeout if isinstance(connect, UnsetType) else connect
+            self.read = timeout if isinstance(read, UnsetType) else read
+            self.write = timeout if isinstance(write, UnsetType) else write
+            self.pool = timeout if isinstance(pool, UnsetType) else pool
+
+    def as_dict(self) -> dict[str, float | None]:
+        return {
+            "connect": self.connect,
+            "read": self.read,
+            "write": self.write,
+            "pool": self.pool,
+        }
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        if len({self.connect, self.read, self.write, self.pool}) == 1:
+            return f"{class_name}(timeout={self.connect})"
+        return f"{class_name}(connect={self.connect}, read={self.read}, write={self.write}, pool={self.pool})"
+
+
+@dataclasses.dataclass(kw_only=True)
+class Limits:
+    """
+    Configuration for limits to various client behaviors.
+
+    **Parameters:**
+
+    * **max_connections** - The maximum number of concurrent connections that may be
+            established.
+    * **max_keepalive_connections** - Allow the connection pool to maintain
+            keep-alive connections below this point. Should be less than or equal
+            to `max_connections`.
+    * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds.
+    """
+
+    max_connections: int | None = None
+    max_keepalive_connections: int | None = None
+    keepalive_expiry: float | None = 5.0
+
+
+class Proxy:
+    def __init__(
+        self,
+        url: URL | str,
+        *,
+        ssl_context: ssl.SSLContext | None = None,
+        auth: tuple[str, str] | None = None,
+        headers: HeaderTypes | None = None,
+    ) -> None:
+        url = URL(url)
+        headers = Headers(headers)
+
+        if url.scheme not in ("http", "https", "socks5", "socks5h"):
+            raise ValueError(f"Unknown scheme for proxy URL {url!r}")
+
+        if url.username or url.password:
+            # Remove any auth credentials from the URL.
+            auth = (url.username, url.password)
+            url = url.copy_with(username=None, password=None)
+
+        self.url = url
+        self.auth = auth
+        self.headers = headers
+        self.ssl_context = ssl_context
+
+    @property
+    def raw_auth(self) -> tuple[bytes, bytes] | None:
+        # The proxy authentication as raw bytes.
+        return None if self.auth is None else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8"))
+
+    def __repr__(self) -> str:
+        # The authentication is represented with the password component masked.
+        auth = (self.auth[0], "********") if self.auth else None
+
+        # Build a nice concise representation.
+        url_str = f"{str(self.url)!r}"
+        auth_str = f", auth={auth!r}" if auth else ""
+        headers_str = f", headers={dict(self.headers)!r}" if self.headers else ""
+        return f"Proxy({url_str}{auth_str}{headers_str})"
+
+
+DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0)
+DEFAULT_LIMITS = Limits(max_connections=100, max_keepalive_connections=20)
+DEFAULT_MAX_REDIRECTS = 20
+
+DEFAULT_MAX_EVENT_SIZE_BYTES = 1024 * 1024
+
+DEFAULT_MAX_MESSAGE_SIZE_BYTES = 65_536
+DEFAULT_QUEUE_SIZE = 512
+DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS = 20.0
+DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS = 20.0
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_content.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_content.py
new file mode 100644
index 0000000000000000000000000000000000000000..3acb2574f121ea039217b046f1e8fc124f381577
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_content.py
@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import inspect
+import warnings
+from collections.abc import AsyncGenerator, AsyncIterable, AsyncIterator, Iterable, Iterator, Mapping
+from json import dumps as json_dumps
+from typing import (
+    Any,
+)
+from urllib.parse import urlencode
+
+from ._exceptions import StreamClosed, StreamConsumed
+from ._multipart import MultipartStream
+from ._types import (
+    AsyncByteStream,
+    RequestContent,
+    RequestData,
+    RequestFiles,
+    ResponseContent,
+    SyncByteStream,
+)
+from ._utils import peek_filelike_remaining_length, primitive_value_to_str
+
+__all__ = ["ByteStream"]
+
+
+class ByteStream(AsyncByteStream, SyncByteStream):
+    def __init__(self, stream: bytes) -> None:
+        self._stream = stream
+
+    def __iter__(self) -> Iterator[bytes]:
+        yield self._stream
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        yield self._stream
+
+
+class IteratorByteStream(SyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: Iterable[bytes]) -> None:
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isgenerator(stream)
+
+    def __iter__(self) -> Iterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "read"):
+            # File-like interfaces should use 'read' directly.
+            chunk = self._stream.read(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = self._stream.read(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate.
+            yield from self._stream
+
+
+class AsyncIteratorByteStream(AsyncByteStream):
+    CHUNK_SIZE = 65_536
+
+    def __init__(self, stream: AsyncIterable[bytes]) -> None:
+        self._stream = stream
+        self._is_stream_consumed = False
+        self._is_generator = inspect.isasyncgen(stream)
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        if self._is_stream_consumed and self._is_generator:
+            raise StreamConsumed()
+
+        self._is_stream_consumed = True
+        if hasattr(self._stream, "aread"):
+            # File-like interfaces should use 'aread' directly.
+            chunk = await self._stream.aread(self.CHUNK_SIZE)
+            while chunk:
+                yield chunk
+                chunk = await self._stream.aread(self.CHUNK_SIZE)
+        else:
+            # Otherwise iterate, making sure the wrapped stream is closed even if the
+            # consumer stops early (e.g. an exception is raised part-way through decoding).
+            stream = self._stream.__aiter__()
+            try:
+                async for part in stream:
+                    yield part
+            finally:
+                if isinstance(stream, AsyncGenerator):
+                    await stream.aclose()
+
+
+class UnattachedStream(AsyncByteStream, SyncByteStream):
+    """
+    If a request or response is serialized using pickle, then it is no longer
+    attached to a stream for I/O purposes. Any stream operations should result
+    in `httpx2.StreamClosed`.
+    """
+
+    def __iter__(self) -> Iterator[bytes]:
+        raise StreamClosed()
+
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise StreamClosed()
+        yield b""  # pragma: no cover
+
+
+def encode_content(
+    content: str | bytes | Iterable[bytes] | AsyncIterable[bytes],
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    if isinstance(content, (bytes, str)):
+        body = content.encode("utf-8") if isinstance(content, str) else content
+        content_length = len(body)
+        headers = {"Content-Length": str(content_length)} if body else {}
+        return headers, ByteStream(body)
+
+    elif isinstance(content, Iterable) and not isinstance(content, dict):
+        # `not isinstance(content, dict)` is a bit oddly specific, but it
+        # catches a case that's easy for users to make in error, and would
+        # otherwise pass through here, like any other bytes-iterable,
+        # because `dict` happens to be iterable. See issue #2491.
+        content_length_or_none = peek_filelike_remaining_length(content)
+
+        if content_length_or_none is None:
+            headers = {"Transfer-Encoding": "chunked"}
+        else:
+            headers = {"Content-Length": str(content_length_or_none)}
+        return headers, IteratorByteStream(content)
+
+    elif isinstance(content, AsyncIterable):
+        headers = {"Transfer-Encoding": "chunked"}
+        return headers, AsyncIteratorByteStream(content)
+
+    raise TypeError(f"Unexpected type for 'content', {type(content)!r}")
+
+
+def encode_urlencoded_data(data: RequestData) -> tuple[dict[str, str], ByteStream]:
+    plain_data: list[tuple[str, str]] = []
+    for key, value in data.items():
+        if isinstance(value, (list, tuple)):
+            plain_data.extend([(key, primitive_value_to_str(item)) for item in value])
+        else:
+            plain_data.append((key, primitive_value_to_str(value)))
+    body = urlencode(plain_data, doseq=True).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/x-www-form-urlencoded"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_multipart_data(
+    data: RequestData, files: RequestFiles, boundary: bytes | None
+) -> tuple[dict[str, str], MultipartStream]:
+    multipart = MultipartStream(data=data, files=files, boundary=boundary)
+    headers = multipart.get_headers()
+    return headers, multipart
+
+
+def encode_text(text: str) -> tuple[dict[str, str], ByteStream]:
+    body = text.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/plain; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_html(html: str) -> tuple[dict[str, str], ByteStream]:
+    body = html.encode("utf-8")
+    content_length = str(len(body))
+    content_type = "text/html; charset=utf-8"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_json(json: Any) -> tuple[dict[str, str], ByteStream]:
+    body = json_dumps(json, ensure_ascii=False, separators=(",", ":"), allow_nan=False).encode("utf-8")
+    content_length = str(len(body))
+    content_type = "application/json"
+    headers = {"Content-Length": content_length, "Content-Type": content_type}
+    return headers, ByteStream(body)
+
+
+def encode_request(
+    content: RequestContent | None = None,
+    data: RequestData | None = None,
+    files: RequestFiles | None = None,
+    json: Any | None = None,
+    boundary: bytes | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    """
+    Handles encoding the given `content`, `data`, `files`, and `json`,
+    returning a two-tuple of (<headers>, <stream>).
+    """
+    if data is not None and not isinstance(data, Mapping):
+        # We prefer to separate `content=<bytes|str|byte iterator|bytes aiterator>`
+        # for raw request content, and `data=<form data>` for url encoded or
+        # multipart form content.
+        #
+        # However for compat with requests, we *do* still support
+        # `data=<bytes...>` usages. We deal with that case here, treating it
+        # as if `content=<...>` had been supplied instead.
+        message = "Use 'content=<...>' to upload raw bytes/text content."
+        warnings.warn(message, DeprecationWarning, stacklevel=2)
+        return encode_content(data)
+
+    if content is not None:
+        return encode_content(content)
+    elif files:
+        return encode_multipart_data(data or {}, files, boundary)
+    elif data:
+        return encode_urlencoded_data(data)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
+
+
+def encode_response(
+    content: ResponseContent | None = None,
+    text: str | None = None,
+    html: str | None = None,
+    json: Any | None = None,
+) -> tuple[dict[str, str], SyncByteStream | AsyncByteStream]:
+    """
+    Handles encoding the given `content`, returning a two-tuple of
+    (<headers>, <stream>).
+    """
+    if content is not None:
+        return encode_content(content)
+    elif text is not None:
+        return encode_text(text)
+    elif html is not None:
+        return encode_html(html)
+    elif json is not None:
+        return encode_json(json)
+
+    return {}, ByteStream(b"")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_decoders.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_decoders.py
new file mode 100644
index 0000000000000000000000000000000000000000..73b302db28ff9293e0055be1cdc17ccb81480452
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_decoders.py
@@ -0,0 +1,458 @@
+"""
+Handlers for Content-Encoding.
+
+See: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Encoding
+"""
+
+from __future__ import annotations
+
+import codecs
+import io
+import itertools
+import sys
+import typing
+import zlib
+
+from ._exceptions import DecodingError
+
+# Brotli support is optional
+try:
+    # The C bindings in `brotli` are recommended for CPython.
+    import brotli
+except ImportError:  # pragma: no cover
+    try:
+        # The CFFI bindings in `brotlicffi` are recommended for PyPy
+        # and other environments.
+        import brotlicffi as brotli
+    except ImportError:
+        brotli = None
+
+
+# Zstandard support is optional on Python <= 3.13.
+# On Python 3.14+, the stdlib includes an optional built-in zstd implementation.
+if typing.TYPE_CHECKING:
+    if sys.version_info >= (3, 14):
+        from compression.zstd import ZstdDecompressor, ZstdError
+    else:
+        from backports.zstd import ZstdDecompressor, ZstdError
+
+    _zstandard_installed: bool
+else:  # pragma: no cover
+    try:
+        if sys.version_info >= (3, 14):
+            from compression.zstd import ZstdDecompressor, ZstdError
+        else:
+            from backports.zstd import ZstdDecompressor, ZstdError
+
+        _zstandard_installed = True
+    except ImportError:
+        _zstandard_installed = False
+
+
+MAX_DECODE_CHUNK_SIZE = 2**20  # 1 MiB
+
+
+class Decompressor(typing.Protocol):
+    @property
+    def unconsumed_tail(self) -> bytes: ...
+
+    def decompress(self, data: bytes, max_length: int) -> bytes: ...
+
+    def flush(self) -> bytes: ...
+
+
+class ZlibDecompressor:
+    """
+    Drain a `zlib`/`gzip` decompressor in bounded pieces so a small compressed
+    input cannot inflate to an unbounded buffer in a single call.
+    """
+
+    def __init__(self, decompressor: Decompressor) -> None:
+        self.decompressor = decompressor
+
+    def decompress(self, data: bytes) -> typing.Iterator[bytes]:
+        decompressed = self.decompressor.decompress(data, MAX_DECODE_CHUNK_SIZE)
+        while decompressed:
+            yield decompressed
+            decompressed = self.decompressor.decompress(self.decompressor.unconsumed_tail, MAX_DECODE_CHUNK_SIZE)
+
+    def flush(self) -> bytes:
+        return self.decompressor.flush()
+
+
+class ContentDecoder:
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        raise NotImplementedError()  # pragma: no cover
+
+    def flush(self) -> typing.Iterator[bytes]:
+        raise NotImplementedError()  # pragma: no cover
+
+
+class IdentityDecoder(ContentDecoder):
+    """
+    Handle unencoded data.
+    """
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        yield data
+
+    def flush(self) -> typing.Iterator[bytes]:
+        yield from ()
+
+
+class DeflateDecoder(ContentDecoder):
+    """
+    Handle 'deflate' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.first_attempt = True
+        self.decompressor = ZlibDecompressor(zlib.decompressobj())
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        was_first_attempt = self.first_attempt
+        self.first_attempt = False
+        try:
+            yield from self.decompressor.decompress(data)
+        except zlib.error as exc:
+            if was_first_attempt:
+                self.decompressor = ZlibDecompressor(zlib.decompressobj(-zlib.MAX_WBITS))
+                yield from self.decode(data)
+            else:
+                raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> typing.Iterator[bytes]:
+        try:
+            yield self.decompressor.flush()
+        except zlib.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+
+
+class GZipDecoder(ContentDecoder):
+    """
+    Handle 'gzip' decoding.
+
+    See: https://stackoverflow.com/questions/1838699
+    """
+
+    def __init__(self) -> None:
+        self.decompressor = ZlibDecompressor(zlib.decompressobj(zlib.MAX_WBITS | 16))
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        try:
+            yield from self.decompressor.decompress(data)
+        except zlib.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> typing.Iterator[bytes]:
+        try:
+            yield self.decompressor.flush()
+        except zlib.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+
+
+class BrotliDecoder(ContentDecoder):
+    """
+    Handle 'brotli' decoding.
+
+    Requires `pip install brotlipy`. See: https://brotlipy.readthedocs.io/
+        or   `pip install brotli`. See https://github.com/google/brotli
+    Supports both 'brotlipy' and 'Brotli' packages since they share an import
+    name. The top branches are for 'brotlipy' and bottom branches for 'Brotli'
+    """
+
+    def __init__(self) -> None:
+        if brotli is None:  # pragma: no cover
+            raise ImportError(
+                "Using 'BrotliDecoder', but neither of the 'brotlicffi' or 'brotli' "
+                "packages have been installed. "
+                "Make sure to install httpx using `pip install httpx[brotli]`."
+            ) from None
+
+        self.decompressor = brotli.Decompressor()
+        self.seen_data = False
+        self._decompress: typing.Callable[..., bytes]
+        if hasattr(self.decompressor, "decompress"):
+            # The 'brotlicffi' package.
+            self._decompress = self.decompressor.decompress  # pragma: no cover
+        else:
+            # The 'brotli' package.
+            self._decompress = self.decompressor.process
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        if not data:
+            return
+        self.seen_data = True
+        try:
+            # The C backend may allocate nearly twice the requested threshold.
+            output_buffer_limit = MAX_DECODE_CHUNK_SIZE // 2
+            decompressed = self._decompress(data, output_buffer_limit=output_buffer_limit)
+            while decompressed:
+                yield decompressed
+                decompressed = self._decompress(b"", output_buffer_limit=output_buffer_limit)
+        except brotli.error as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> typing.Iterator[bytes]:
+        if not self.seen_data:
+            return
+        try:
+            if hasattr(self.decompressor, "finish"):
+                # Only available in the 'brotlicffi' package.
+
+                # As the decompressor decompresses eagerly, this
+                # will never actually emit any data. However, it will potentially throw
+                # errors if a truncated or damaged data stream has been used.
+                self.decompressor.finish()  # pragma: no cover
+        except brotli.error as exc:  # pragma: no cover
+            raise DecodingError(str(exc)) from exc
+        yield from ()
+
+
+class ZStandardDecoder(ContentDecoder):
+    """Handle 'zstd' RFC 8878 decoding.
+
+    On Python 3.13 and below, this requires `pip install httpx2[zstd]`.
+    """
+
+    # inspired by the ZstdDecoder implementation in urllib3
+    def __init__(self) -> None:
+        if not _zstandard_installed:  # pragma: no cover
+            raise ImportError(
+                "Using 'ZStandardDecoder', ...Make sure to install httpx using `pip install httpx[zstd]`."
+            ) from None
+
+        self.decompressor = ZstdDecompressor()
+        self.seen_data = False
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        if not data:
+            return
+        self.seen_data = True
+        try:
+            if self.decompressor.eof:
+                data = self.decompressor.unused_data + data
+                self.decompressor = ZstdDecompressor()
+            while True:
+                decompressed = self.decompressor.decompress(data, MAX_DECODE_CHUNK_SIZE)
+                while decompressed:
+                    yield decompressed
+                    if self.decompressor.needs_input or self.decompressor.eof:
+                        break
+                    decompressed = self.decompressor.decompress(b"", MAX_DECODE_CHUNK_SIZE)
+                if not (self.decompressor.eof and self.decompressor.unused_data):
+                    break
+                data = self.decompressor.unused_data
+                self.decompressor = ZstdDecompressor()
+        except ZstdError as exc:
+            raise DecodingError(str(exc)) from exc
+
+    def flush(self) -> typing.Iterator[bytes]:
+        if not self.seen_data:
+            return
+        if not self.decompressor.eof:
+            raise DecodingError("Zstandard data is incomplete")  # pragma: no cover
+        yield from ()
+
+
+class MultiDecoder(ContentDecoder):
+    """
+    Handle the case where multiple encodings have been applied.
+    """
+
+    max_decode_links: typing.ClassVar[int] = 5
+
+    def __init__(self, encodings: typing.Sequence[str]) -> None:
+        """
+        'encodings' should be the content codings in the order in which
+        each was applied.
+        """
+        codings = [encoding for encoding in encodings if encoding in SUPPORTED_DECODERS]
+        if len(codings) > self.max_decode_links:
+            raise DecodingError(f"Cannot apply more than {self.max_decode_links} content encodings.")
+        # Note that we reverse the order for decoding.
+        self.children: list[ContentDecoder] = [SUPPORTED_DECODERS[coding]() for coding in reversed(codings)]
+
+    def decode(self, data: bytes) -> typing.Iterator[bytes]:
+        streams: typing.Iterator[bytes] = iter((data,))
+        for child in self.children:
+            streams = self._pipe(child.decode, streams)
+        yield from streams
+
+    def flush(self) -> typing.Iterator[bytes]:
+        streams: typing.Iterator[bytes] = iter(())
+        for child in self.children:
+            streams = itertools.chain(self._pipe(child.decode, streams), child.flush())
+        yield from streams
+
+    @staticmethod
+    def _pipe(
+        decode: typing.Callable[[bytes], typing.Iterator[bytes]],
+        upstream: typing.Iterator[bytes],
+    ) -> typing.Iterator[bytes]:
+        for chunk in upstream:
+            yield from decode(chunk)
+
+
+class ByteChunker:
+    """
+    Handles returning byte content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: int | None = None) -> None:
+        self._buffer = io.BytesIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: bytes) -> list[bytes]:
+        if self._chunk_size is None:
+            return [content] if content else []
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [value[i : i + self._chunk_size] for i in range(0, len(value), self._chunk_size)]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> list[bytes]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextChunker:
+    """
+    Handles returning text content in fixed-size chunks.
+    """
+
+    def __init__(self, chunk_size: int | None = None) -> None:
+        self._buffer = io.StringIO()
+        self._chunk_size = chunk_size
+
+    def decode(self, content: str) -> list[str]:
+        if self._chunk_size is None:
+            return [content] if content else []
+
+        self._buffer.write(content)
+        if self._buffer.tell() >= self._chunk_size:
+            value = self._buffer.getvalue()
+            chunks = [value[i : i + self._chunk_size] for i in range(0, len(value), self._chunk_size)]
+            if len(chunks[-1]) == self._chunk_size:
+                self._buffer.seek(0)
+                self._buffer.truncate()
+                return chunks
+            else:
+                self._buffer.seek(0)
+                self._buffer.write(chunks[-1])
+                self._buffer.truncate()
+                return chunks[:-1]
+        else:
+            return []
+
+    def flush(self) -> list[str]:
+        value = self._buffer.getvalue()
+        self._buffer.seek(0)
+        self._buffer.truncate()
+        return [value] if value else []
+
+
+class TextDecoder:
+    """
+    Handles incrementally decoding bytes into text
+    """
+
+    def __init__(self, encoding: str = "utf-8") -> None:
+        self.decoder = codecs.getincrementaldecoder(encoding)(errors="replace")
+
+    def decode(self, data: bytes) -> str:
+        return self.decoder.decode(data)
+
+    def flush(self) -> str:
+        return self.decoder.decode(b"", True)
+
+
+class LineDecoder:
+    """
+    Handles incrementally reading lines from text.
+
+    Has the same behaviour as the stdllib splitlines,
+    but handling the input iteratively.
+    """
+
+    def __init__(self) -> None:
+        self.buffer: list[str] = []
+        self.trailing_cr: bool = False
+
+    def decode(self, text: str) -> list[str]:
+        # See https://docs.python.org/3/library/stdtypes.html#str.splitlines
+        NEWLINE_CHARS = "\n\r\x0b\x0c\x1c\x1d\x1e\x85\u2028\u2029"
+
+        # We always push a trailing `\r` into the next decode iteration.
+        if self.trailing_cr:
+            text = "\r" + text
+            self.trailing_cr = False
+        if text.endswith("\r"):
+            self.trailing_cr = True
+            text = text[:-1]
+
+        if not text:
+            # NOTE: the edge case input of empty text doesn't occur in practice,
+            # because other httpx internals filter out this value
+            return []  # pragma: no cover
+
+        trailing_newline = text[-1] in NEWLINE_CHARS
+        lines = text.splitlines()
+
+        if len(lines) == 1 and not trailing_newline:
+            # No new lines, buffer the input and continue.
+            self.buffer.append(lines[0])
+            return []
+
+        if self.buffer:
+            # Include any existing buffer in the first portion of the
+            # splitlines result.
+            lines = ["".join(self.buffer) + lines[0]] + lines[1:]
+            self.buffer = []
+
+        if not trailing_newline:
+            # If the last segment of splitlines is not newline terminated,
+            # then drop it from our output and start a new buffer.
+            self.buffer = [lines.pop()]
+
+        return lines
+
+    def flush(self) -> list[str]:
+        if not self.buffer and not self.trailing_cr:
+            return []
+
+        lines = ["".join(self.buffer)]
+        self.buffer = []
+        self.trailing_cr = False
+        return lines
+
+
+SUPPORTED_DECODERS: dict[str, type[ContentDecoder]] = {
+    "identity": IdentityDecoder,
+    "gzip": GZipDecoder,
+    "deflate": DeflateDecoder,
+    "br": BrotliDecoder,
+    "zstd": ZStandardDecoder,
+}
+
+
+if brotli is None:
+    SUPPORTED_DECODERS.pop("br")  # pragma: no cover
+if not _zstandard_installed:
+    SUPPORTED_DECODERS.pop("zstd")  # pragma: no cover
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..2b74151b4fd0166c40e68f87149bc548018a7fdb
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_exceptions.py
@@ -0,0 +1,380 @@
+"""
+Our exception hierarchy:
+
+* HTTPError
+  x RequestError
+    + TransportError
+      - TimeoutException
+        · ConnectTimeout
+        · ReadTimeout
+        · WriteTimeout
+        · PoolTimeout
+      - NetworkError
+        · ConnectError
+        · ReadError
+        · WriteError
+        · CloseError
+      - ProtocolError
+        · LocalProtocolError
+        · RemoteProtocolError
+      - ProxyError
+      - UnsupportedProtocol
+    + DecodingError
+    + TooManyRedirects
+  x HTTPStatusError
+* InvalidURL
+* CookieConflict
+* StreamError
+  x StreamConsumed
+  x StreamClosed
+  x ResponseNotRead
+  x RequestNotRead
+"""
+
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import Generator
+
+if typing.TYPE_CHECKING:
+    from ._models import Request, Response  # pragma: no cover
+
+__all__ = [
+    "CloseError",
+    "ConnectError",
+    "ConnectTimeout",
+    "CookieConflict",
+    "DecodingError",
+    "HTTPError",
+    "HTTPStatusError",
+    "InvalidURL",
+    "LocalProtocolError",
+    "NetworkError",
+    "PoolTimeout",
+    "ProtocolError",
+    "ProxyError",
+    "ReadError",
+    "ReadTimeout",
+    "RemoteProtocolError",
+    "RequestError",
+    "RequestNotRead",
+    "ResponseNotRead",
+    "StreamClosed",
+    "StreamConsumed",
+    "StreamError",
+    "TimeoutException",
+    "TooManyRedirects",
+    "TransportError",
+    "UnsupportedProtocol",
+    "WriteError",
+    "WriteTimeout",
+]
+
+
+class HTTPXDeprecationWarning(UserWarning):
+    """A custom deprecation warning for HTTPX.
+
+    Unlike the built-in `DeprecationWarning`, this inherits from `UserWarning` to ensure it is visible by default,
+    helping users discover deprecated features without needing to enable warnings explicitly.
+
+    Reference: https://sethmlarson.dev/deprecations-via-warnings-dont-work-for-python-libraries
+    """
+
+
+class HTTPError(Exception):
+    """
+    Base class for `RequestError` and `HTTPStatusError`.
+
+    Useful for `try...except` blocks when issuing a request,
+    and then calling `.raise_for_status()`.
+
+    For example:
+
+    ```
+    try:
+        response = httpx2.get("https://www.example.com")
+        response.raise_for_status()
+    except httpx2.HTTPError as exc:
+        print(f"HTTP Exception for {exc.request.url} - {exc}")
+    ```
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+        self._request: Request | None = None
+
+    @property
+    def request(self) -> Request:
+        if self._request is None:
+            raise RuntimeError("The .request property has not been set.")
+        return self._request
+
+    @request.setter
+    def request(self, request: Request) -> None:
+        self._request = request
+
+
+class RequestError(HTTPError):
+    """
+    Base class for all exceptions that may occur when issuing a `.request()`.
+    """
+
+    def __init__(self, message: str, *, request: Request | None = None) -> None:
+        super().__init__(message)
+        # At the point an exception is raised we won't typically have a request
+        # instance to associate it with.
+        #
+        # The 'request_context' context manager is used within the Client and
+        # Response methods in order to ensure that any raised exceptions
+        # have a `.request` property set on them.
+        self._request = request
+
+
+class TransportError(RequestError):
+    """
+    Base class for all exceptions that occur at the level of the Transport API.
+    """
+
+
+# Timeout exceptions...
+
+
+class TimeoutException(TransportError):
+    """
+    The base class for timeout errors.
+
+    An operation has timed out.
+    """
+
+
+class ConnectTimeout(TimeoutException):
+    """
+    Timed out while connecting to the host.
+    """
+
+
+class ReadTimeout(TimeoutException):
+    """
+    Timed out while receiving data from the host.
+    """
+
+
+class WriteTimeout(TimeoutException):
+    """
+    Timed out while sending data to the host.
+    """
+
+
+class PoolTimeout(TimeoutException):
+    """
+    Timed out waiting to acquire a connection from the pool.
+    """
+
+
+# Core networking exceptions...
+
+
+class NetworkError(TransportError):
+    """
+    The base class for network-related errors.
+
+    An error occurred while interacting with the network.
+    """
+
+
+class ReadError(NetworkError):
+    """
+    Failed to receive data from the network.
+    """
+
+
+class WriteError(NetworkError):
+    """
+    Failed to send data through the network.
+    """
+
+
+class ConnectError(NetworkError):
+    """
+    Failed to establish a connection.
+    """
+
+
+class CloseError(NetworkError):
+    """
+    Failed to close a connection.
+    """
+
+
+# Other transport exceptions...
+
+
+class ProxyError(TransportError):
+    """
+    An error occurred while establishing a proxy connection.
+    """
+
+
+class UnsupportedProtocol(TransportError):
+    """
+    Attempted to make a request to an unsupported protocol.
+
+    For example issuing a request to `ftp://www.example.com`.
+    """
+
+
+class ProtocolError(TransportError):
+    """
+    The protocol was violated.
+    """
+
+
+class LocalProtocolError(ProtocolError):
+    """
+    A protocol was violated by the client.
+
+    For example if the user instantiated a `Request` instance explicitly,
+    failed to include the mandatory `Host:` header, and then issued it directly
+    using `client.send()`.
+    """
+
+
+class RemoteProtocolError(ProtocolError):
+    """
+    The protocol was violated by the server.
+
+    For example, returning malformed HTTP.
+    """
+
+
+# Other request exceptions...
+
+
+class DecodingError(RequestError):
+    """
+    Decoding of the response failed, due to a malformed encoding.
+    """
+
+
+class TooManyRedirects(RequestError):
+    """
+    Too many redirects.
+    """
+
+
+# Client errors
+
+
+class HTTPStatusError(HTTPError):
+    """
+    The response had an error HTTP status of 4xx or 5xx.
+
+    May be raised when calling `response.raise_for_status()`
+    """
+
+    def __init__(self, message: str, *, request: Request, response: Response) -> None:
+        super().__init__(message)
+        self.request = request
+        self.response = response
+
+
+class InvalidURL(Exception):
+    """
+    URL is improperly formed or cannot be parsed.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class CookieConflict(Exception):
+    """
+    Attempted to lookup a cookie by name, but multiple cookies existed.
+
+    Can occur when calling `response.cookies.get(...)`.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+# Stream exceptions...
+
+# These may occur as the result of a programming error, by accessing
+# the request/response stream in an invalid manner.
+
+
+class StreamError(RuntimeError):
+    """
+    The base class for stream exceptions.
+
+    The developer made an error in accessing the request stream in
+    an invalid way.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message)
+
+
+class StreamConsumed(StreamError):
+    """
+    Attempted to read or stream content, but the content has already
+    been streamed.
+    """
+
+    def __init__(self) -> None:
+        message = (
+            "Attempted to read or stream some content, but the content has "
+            "already been streamed. For requests, this could be due to passing "
+            "a generator as request content, and then receiving a redirect "
+            "response or a secondary request as part of an authentication flow."
+            "For responses, this could be due to attempting to stream the response "
+            "content more than once."
+        )
+        super().__init__(message)
+
+
+class StreamClosed(StreamError):
+    """
+    Attempted to read or stream response content, but the request has been
+    closed.
+    """
+
+    def __init__(self) -> None:
+        message = "Attempted to read or stream content, but the stream has been closed."
+        super().__init__(message)
+
+
+class ResponseNotRead(StreamError):
+    """
+    Attempted to access streaming response content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = "Attempted to access streaming response content, without having called `read()`."
+        super().__init__(message)
+
+
+class RequestNotRead(StreamError):
+    """
+    Attempted to access streaming request content, without having called `read()`.
+    """
+
+    def __init__(self) -> None:
+        message = "Attempted to access streaming request content, without having called `read()`."
+        super().__init__(message)
+
+
+@contextlib.contextmanager
+def request_context(request: Request | None = None) -> Generator[None]:
+    """
+    A context manager that can be used to attach the given request context
+    to any `RequestError` exceptions that are raised within the block.
+    """
+    try:
+        yield
+    except RequestError as exc:
+        if request is not None:
+            exc.request = request
+        raise exc
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_main.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_main.py
new file mode 100644
index 0000000000000000000000000000000000000000..e53f3940a2aa9dc04e2e5dbba4f98e39695d4518
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_main.py
@@ -0,0 +1,483 @@
+from __future__ import annotations
+
+import functools
+import json
+import sys
+import typing
+
+import click
+import pygments.lexers
+import pygments.util
+import rich.console
+import rich.markup
+import rich.progress
+import rich.syntax
+import rich.table
+
+from ._client import Client
+from ._exceptions import RequestError
+from ._models import Response
+from ._status_codes import codes
+
+if typing.TYPE_CHECKING:
+    import httpcore2  # pragma: no cover
+
+
+def print_help() -> None:
+    console = rich.console.Console()
+
+    console.print("[bold]HTTPX :butterfly:", justify="center")
+    console.print()
+    console.print("A next generation HTTP client.", justify="center")
+    console.print()
+    console.print("Usage: [bold]httpx2[/bold] [cyan]<URL> [OPTIONS][/cyan] ", justify="left")
+    console.print()
+
+    table = rich.table.Table.grid(padding=1, pad_edge=True)
+    table.add_column("Parameter", no_wrap=True, justify="left", style="bold")
+    table.add_column("Description")
+    table.add_row(
+        "-m, --method [cyan]METHOD",
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD, QUERY.\n"
+        "[Default: GET, or POST if a request body is included]",
+    )
+    table.add_row(
+        "-p, --params [cyan]<NAME VALUE> ...",
+        "Query parameters to include in the request URL.",
+    )
+    table.add_row("-c, --content [cyan]TEXT", "Byte content to include in the request body.")
+    table.add_row("-d, --data [cyan]<NAME VALUE> ...", "Form data to include in the request body.")
+    table.add_row(
+        "-f, --files [cyan]<NAME FILENAME> ...",
+        "Form files to include in the request body.",
+    )
+    table.add_row("-j, --json [cyan]TEXT", "JSON data to include in the request body.")
+    table.add_row(
+        "-h, --headers [cyan]<NAME VALUE> ...",
+        "Include additional HTTP headers in the request.",
+    )
+    table.add_row("--cookies [cyan]<NAME VALUE> ...", "Cookies to include in the request.")
+    table.add_row(
+        "--auth [cyan]<USER PASS>",
+        "Username and password to include in the request. Specify '-' for the password"
+        " to use a password prompt. Note that using --verbose/-v will expose"
+        " the Authorization header, including the password encoding"
+        " in a trivially reversible format.",
+    )
+
+    table.add_row(
+        "--proxy [cyan]URL",
+        "Send the request via a proxy. Should be the URL giving the proxy address.",
+    )
+
+    table.add_row(
+        "--timeout [cyan]FLOAT",
+        "Timeout value to use for network operations, such as establishing the"
+        " connection, reading some data, etc... [Default: 5.0]",
+    )
+
+    table.add_row("--follow-redirects", "Automatically follow redirects.")
+    table.add_row("--verify / --no-verify", "Enable SSL verification.")
+    table.add_row("--http2", "Send the request using HTTP/2, if the remote server supports it.")
+
+    table.add_row(
+        "--download [cyan]FILE",
+        "Save the response content as a file, rather than displaying it.",
+    )
+
+    table.add_row("-v, --verbose", "Verbose output. Show request as well as response.")
+    table.add_row("--help", "Show this message and exit.")
+    console.print(table)
+
+
+def get_lexer_for_response(response: Response) -> str:
+    content_type = response.headers.get("Content-Type")
+    if content_type is not None:
+        mime_type, _, _ = content_type.partition(";")
+        try:
+            return typing.cast(str, pygments.lexers.get_lexer_for_mimetype(mime_type.strip()).name)
+        except pygments.util.ClassNotFound:  # pragma: no cover
+            pass
+    return ""  # pragma: no cover
+
+
+def format_request_headers(request: httpcore2.Request, http2: bool = False) -> str:
+    version = "HTTP/2" if http2 else "HTTP/1.1"
+    headers = [(name.lower() if http2 else name, value) for name, value in request.headers]
+    method = request.method.decode("ascii")
+    target = request.url.target.decode("ascii")
+    lines = [f"{method} {target} {version}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def format_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> str:
+    version = http_version.decode("ascii")
+    reason = codes.get_reason_phrase(status) if reason_phrase is None else reason_phrase.decode("ascii")
+    lines = [f"{version} {status} {reason}"] + [
+        f"{name.decode('ascii')}: {value.decode('ascii')}" for name, value in headers
+    ]
+    return "\n".join(lines)
+
+
+def print_request_headers(request: httpcore2.Request, http2: bool = False) -> None:
+    console = rich.console.Console()
+    http_text = format_request_headers(request, http2=http2)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response_headers(
+    http_version: bytes,
+    status: int,
+    reason_phrase: bytes | None,
+    headers: list[tuple[bytes, bytes]],
+) -> None:
+    console = rich.console.Console()
+    http_text = format_response_headers(http_version, status, reason_phrase, headers)
+    syntax = rich.syntax.Syntax(http_text, "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+    syntax = rich.syntax.Syntax("", "http", theme="ansi_dark", word_wrap=True)
+    console.print(syntax)
+
+
+def print_response(response: Response) -> None:
+    console = rich.console.Console()
+    lexer_name = get_lexer_for_response(response)
+    if lexer_name:
+        if lexer_name.lower() == "json":
+            try:
+                data = response.json()
+                text = json.dumps(data, indent=4)
+            except ValueError:  # pragma: no cover
+                text = response.text
+        else:
+            text = response.text
+
+        syntax = rich.syntax.Syntax(text, lexer_name, theme="ansi_dark", word_wrap=True)
+        console.print(syntax)
+    else:
+        console.print(f"<{len(response.content)} bytes of binary data>")
+
+
+_PCTRTT = tuple[tuple[str, str], ...]
+_PCTRTTT = tuple[_PCTRTT, ...]
+_PeerCertRetDictType = dict[str, str | _PCTRTTT | _PCTRTT]
+
+
+def format_certificate(cert: _PeerCertRetDictType) -> str:  # pragma: no cover
+    lines: list[str] = []
+    for key, value in cert.items():
+        if isinstance(value, (list, tuple)):
+            lines.append(f"*   {key}:")
+            for item in value:
+                if key in ("subject", "issuer"):
+                    lines.extend(f"*     {sub_item[0]}: {sub_item[1]!r}" for sub_item in item)
+                elif isinstance(item, tuple) and len(item) == 2:
+                    lines.append(f"*     {item[0]}: {item[1]!r}")
+                else:
+                    lines.append(f"*     {item!r}")
+        else:
+            lines.append(f"*   {key}: {value!r}")
+    return "\n".join(lines)
+
+
+def trace(name: str, info: typing.Mapping[str, typing.Any], verbose: bool = False) -> None:
+    console = rich.console.Console()
+    if name == "connection.connect_tcp.started" and verbose:
+        host = info["host"]
+        console.print(f"* Connecting to {host!r}")
+    elif name == "connection.connect_tcp.complete" and verbose:
+        stream = info["return_value"]
+        server_addr = stream.get_extra_info("server_addr")
+        console.print(f"* Connected to {server_addr[0]!r} on port {server_addr[1]}")
+    elif name == "connection.start_tls.complete" and verbose:  # pragma: no cover
+        stream = info["return_value"]
+        ssl_object = stream.get_extra_info("ssl_object")
+        version = ssl_object.version()
+        cipher = ssl_object.cipher()
+        server_cert = ssl_object.getpeercert()
+        alpn = ssl_object.selected_alpn_protocol()
+        console.print(f"* SSL established using {version!r} / {cipher[0]!r}")
+        console.print(f"* Selected ALPN protocol: {alpn!r}")
+        if server_cert:
+            console.print("* Server certificate:")
+            console.print(format_certificate(server_cert))
+    elif name == "http11.send_request_headers.started" and verbose:
+        request = info["request"]
+        print_request_headers(request, http2=False)
+    elif name == "http2.send_request_headers.started" and verbose:  # pragma: no cover
+        request = info["request"]
+        print_request_headers(request, http2=True)
+    elif name == "http11.receive_response_headers.complete":
+        http_version, status, reason_phrase, headers = info["return_value"]
+        print_response_headers(http_version, status, reason_phrase, headers)
+    elif name == "http2.receive_response_headers.complete":  # pragma: no cover
+        status, headers = info["return_value"]
+        http_version = b"HTTP/2"
+        reason_phrase = None
+        print_response_headers(http_version, status, reason_phrase, headers)
+
+
+def download_response(response: Response, download: typing.BinaryIO) -> None:
+    console = rich.console.Console()
+    console.print()
+    content_length = response.headers.get("Content-Length")
+    with rich.progress.Progress(
+        "[progress.description]{task.description}",
+        "[progress.percentage]{task.percentage:>3.0f}%",
+        rich.progress.BarColumn(bar_width=None),
+        rich.progress.DownloadColumn(),
+        rich.progress.TransferSpeedColumn(),
+    ) as progress:
+        description = f"Downloading [bold]{rich.markup.escape(download.name)}"
+        download_task = progress.add_task(
+            description,
+            total=int(content_length or 0),
+            start=content_length is not None,
+        )
+        for chunk in response.iter_bytes():
+            download.write(chunk)
+            progress.update(download_task, completed=response.num_bytes_downloaded)
+
+
+def validate_json(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value is None:
+        return None
+
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:  # pragma: no cover
+        raise click.BadParameter("Not valid JSON")
+
+
+def validate_auth(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> typing.Any:
+    if value == (None, None):
+        return None
+
+    username, password = value
+    if password == "-":  # pragma: no cover
+        password = click.prompt("Password", hide_input=True)
+    return (username, password)
+
+
+def handle_help(
+    ctx: click.Context,
+    param: click.Option | click.Parameter,
+    value: typing.Any,
+) -> None:
+    if not value or ctx.resilient_parsing:
+        return
+
+    print_help()
+    ctx.exit()
+
+
+@click.command(add_help_option=False)
+@click.argument("url", type=str)
+@click.option(
+    "--method",
+    "-m",
+    "method",
+    type=str,
+    help=(
+        "Request method, such as GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD, QUERY. "
+        "[Default: GET, or POST if a request body is included]"
+    ),
+)
+@click.option(
+    "--params",
+    "-p",
+    "params",
+    type=(str, str),
+    multiple=True,
+    help="Query parameters to include in the request URL.",
+)
+@click.option(
+    "--content",
+    "-c",
+    "content",
+    type=str,
+    help="Byte content to include in the request body.",
+)
+@click.option(
+    "--data",
+    "-d",
+    "data",
+    type=(str, str),
+    multiple=True,
+    help="Form data to include in the request body.",
+)
+@click.option(
+    "--files",
+    "-f",
+    "files",
+    type=(str, click.File(mode="rb")),
+    multiple=True,
+    help="Form files to include in the request body.",
+)
+@click.option(
+    "--json",
+    "-j",
+    "json",
+    type=str,
+    callback=validate_json,
+    help="JSON data to include in the request body.",
+)
+@click.option(
+    "--headers",
+    "-h",
+    "headers",
+    type=(str, str),
+    multiple=True,
+    help="Include additional HTTP headers in the request.",
+)
+@click.option(
+    "--cookies",
+    "cookies",
+    type=(str, str),
+    multiple=True,
+    help="Cookies to include in the request.",
+)
+@click.option(
+    "--auth",
+    "auth",
+    type=(str, str),
+    default=(None, None),
+    callback=validate_auth,
+    help=(
+        "Username and password to include in the request. "
+        "Specify '-' for the password to use a password prompt. "
+        "Note that using --verbose/-v will expose the Authorization header, "
+        "including the password encoding in a trivially reversible format."
+    ),
+)
+@click.option(
+    "--proxy",
+    "proxy",
+    type=str,
+    default=None,
+    help="Send the request via a proxy. Should be the URL giving the proxy address.",
+)
+@click.option(
+    "--timeout",
+    "timeout",
+    type=float,
+    default=5.0,
+    help=(
+        "Timeout value to use for network operations, such as establishing the "
+        "connection, reading some data, etc... [Default: 5.0]"
+    ),
+)
+@click.option(
+    "--follow-redirects",
+    "follow_redirects",
+    is_flag=True,
+    default=False,
+    help="Automatically follow redirects.",
+)
+@click.option(
+    "--verify/--no-verify",
+    default=True,
+    help="Enable SSL verification.",
+)
+@click.option(
+    "--http2",
+    "http2",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Send the request using HTTP/2, if the remote server supports it.",
+)
+@click.option(
+    "--download",
+    type=click.File("wb"),
+    help="Save the response content as a file, rather than displaying it.",
+)
+@click.option(
+    "--verbose",
+    "-v",
+    type=bool,
+    is_flag=True,
+    default=False,
+    help="Verbose. Show request as well as response.",
+)
+@click.option(
+    "--help",
+    is_flag=True,
+    is_eager=True,
+    expose_value=False,
+    callback=handle_help,
+    help="Show this message and exit.",
+)
+def main(
+    url: str,
+    method: str,
+    params: list[tuple[str, str]],
+    content: str,
+    data: list[tuple[str, str]],
+    files: list[tuple[str, click.File]],
+    json: str,
+    headers: list[tuple[str, str]],
+    cookies: list[tuple[str, str]],
+    auth: tuple[str, str] | None,
+    proxy: str,
+    timeout: float,
+    follow_redirects: bool,
+    verify: bool,
+    http2: bool,
+    download: typing.BinaryIO | None,
+    verbose: bool,
+) -> None:
+    """
+    An HTTP command line client.
+    Sends a request and displays the response.
+    """
+    if not method:
+        method = "POST" if content or data or files or json else "GET"
+
+    try:
+        with Client(proxy=proxy, timeout=timeout, http2=http2, verify=verify) as client:
+            with client.stream(
+                method,
+                url,
+                params=list(params),
+                content=content,
+                data=dict(data),
+                files=files,  # type: ignore[arg-type]
+                json=json,
+                headers=headers,
+                cookies=dict(cookies),
+                auth=auth,
+                follow_redirects=follow_redirects,
+                extensions={"trace": functools.partial(trace, verbose=verbose)},
+            ) as response:
+                if download is not None:
+                    download_response(response, download)
+                else:
+                    response.read()
+                    if response.content:
+                        print_response(response)
+
+    except RequestError as exc:
+        console = rich.console.Console()
+        console.print(f"[red]{type(exc).__name__}[/red]: {exc}")
+        sys.exit(1)
+
+    sys.exit(0 if response.is_success else 1)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_models.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_models.py
new file mode 100644
index 0000000000000000000000000000000000000000..0272f36d992d70cfce9b278109353222b7e29434
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_models.py
@@ -0,0 +1,1273 @@
+from __future__ import annotations
+
+import codecs
+import contextlib
+import datetime
+import email.message
+import json as jsonlib
+import re
+import typing
+import urllib.request
+from collections.abc import AsyncGenerator, Mapping
+from http.cookiejar import Cookie, CookieJar
+
+from ._content import ByteStream, UnattachedStream, encode_request, encode_response
+from ._decoders import (
+    ByteChunker,
+    ContentDecoder,
+    IdentityDecoder,
+    LineDecoder,
+    MultiDecoder,
+    TextChunker,
+    TextDecoder,
+)
+from ._exceptions import (
+    CookieConflict,
+    HTTPStatusError,
+    RequestNotRead,
+    ResponseNotRead,
+    StreamClosed,
+    StreamConsumed,
+    request_context,
+)
+from ._multipart import get_multipart_boundary_from_content_type
+from ._status_codes import codes
+from ._types import (
+    AsyncByteStream,
+    CookieTypes,
+    HeaderTypes,
+    QueryParamTypes,
+    RequestContent,
+    RequestData,
+    RequestExtensions,
+    RequestFiles,
+    ResponseContent,
+    ResponseExtensions,
+    SyncByteStream,
+)
+from ._urls import URL
+from ._utils import to_bytes_or_str, to_str
+
+__all__ = ["Cookies", "Headers", "Request", "Response"]
+
+SENSITIVE_HEADERS = {"authorization", "proxy-authorization"}
+
+_T = typing.TypeVar("_T")
+
+
+def _is_known_encoding(encoding: str) -> bool:
+    """
+    Return `True` if `encoding` is a known codec.
+    """
+    try:
+        codecs.lookup(encoding)
+    except LookupError:
+        return False
+    return True
+
+
+def _normalize_header_key(key: str | bytes, encoding: str | None = None) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header key.
+    """
+    return key if isinstance(key, bytes) else key.encode(encoding or "ascii")
+
+
+def _normalize_header_value(value: str | bytes, encoding: str | None = None) -> bytes:
+    """
+    Coerce str/bytes into a strictly byte-wise HTTP header value.
+    """
+    if isinstance(value, bytes):
+        return value
+    if not isinstance(value, str):
+        raise TypeError(f"Header value must be str or bytes, not {type(value)}")
+    return value.encode(encoding or "ascii")
+
+
+def _parse_content_type_charset(content_type: str) -> str | None:
+    # We used to use `cgi.parse_header()` here, but `cgi` became a dead battery.
+    # See: https://peps.python.org/pep-0594/#cgi
+    msg = email.message.Message()
+    msg["content-type"] = content_type
+    return msg.get_content_charset(failobj=None)
+
+
+def _parse_header_links(value: str) -> list[dict[str, str]]:
+    """
+    Returns a list of parsed link headers, for more info see:
+    https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Link
+    The generic syntax of those is:
+    Link: < uri-reference >; param1=value1; param2="value2"
+    So for instance:
+    Link; '<http:/.../front.jpeg>; type="image/jpeg",<http://.../back.jpeg>;'
+    would return
+        [
+            {"url": "http:/.../front.jpeg", "type": "image/jpeg"},
+            {"url": "http://.../back.jpeg"},
+        ]
+    :param value: HTTP Link entity-header field
+    :return: list of parsed link headers
+    """
+    links: list[dict[str, str]] = []
+    replace_chars = " '\""
+    value = value.strip(replace_chars)
+    if not value:
+        return links
+    for val in re.split(", *<", value):
+        try:
+            url, params = val.split(";", 1)
+        except ValueError:
+            url, params = val, ""
+        link = {"url": url.strip("<> '\"")}
+        for param in params.split(";"):
+            try:
+                key, value = param.split("=")
+            except ValueError:
+                break
+            link[key.strip(replace_chars)] = value.strip(replace_chars)
+        links.append(link)
+    return links
+
+
+def _obfuscate_sensitive_headers(
+    items: typing.Iterable[tuple[typing.AnyStr, typing.AnyStr]],
+) -> typing.Iterator[tuple[typing.AnyStr, typing.AnyStr]]:
+    for k, v in items:
+        if to_str(k.lower()) in SENSITIVE_HEADERS:
+            v = to_bytes_or_str("[secure]", match_type_of=v)
+        yield k, v
+
+
+class Headers(typing.MutableMapping[str, str]):
+    """
+    HTTP headers, as a case-insensitive multi-dict.
+    """
+
+    def __init__(
+        self,
+        headers: HeaderTypes | None = None,
+        encoding: str | None = None,
+    ) -> None:
+        self._list: list[tuple[bytes, bytes, bytes]] = []
+
+        if isinstance(headers, Headers):
+            self._list = list(headers._list)
+        elif isinstance(headers, Mapping):
+            for k, v in headers.items():
+                bytes_key = _normalize_header_key(k, encoding)
+                bytes_value = _normalize_header_value(v, encoding)
+                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
+        elif headers is not None:
+            for k, v in headers:
+                bytes_key = _normalize_header_key(k, encoding)
+                bytes_value = _normalize_header_value(v, encoding)
+                self._list.append((bytes_key, bytes_key.lower(), bytes_value))
+
+        self._encoding = encoding
+
+    @property
+    def encoding(self) -> str:
+        """
+        Header encoding is mandated as ascii, but we allow fallbacks to utf-8
+        or iso-8859-1.
+        """
+        if self._encoding is None:
+            for encoding in ["ascii", "utf-8"]:
+                for key, value in self.raw:
+                    try:
+                        key.decode(encoding)
+                        value.decode(encoding)
+                    except UnicodeDecodeError:
+                        break
+                else:
+                    # The else block runs if 'break' did not occur, meaning
+                    # all values fitted the encoding.
+                    self._encoding = encoding
+                    break
+            else:
+                # The ISO-8859-1 encoding covers all 256 code points in a byte,
+                # so will never raise decode errors.
+                self._encoding = "iso-8859-1"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        self._encoding = value
+
+    @property
+    def raw(self) -> list[tuple[bytes, bytes]]:
+        """
+        Returns a list of the raw header items, as byte pairs.
+        """
+        return [(raw_key, value) for raw_key, _, value in self._list]
+
+    def keys(self) -> typing.KeysView[str]:
+        return {key.decode(self.encoding): None for _, key, _value in self._list}.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        values_dict: dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return `(key, value)` items of headers. Concatenate headers
+        into a single comma separated value when a key occurs multiple times.
+        """
+        values_dict: dict[str, str] = {}
+        for _, key, value in self._list:
+            str_key = key.decode(self.encoding)
+            str_value = value.decode(self.encoding)
+            if str_key in values_dict:
+                values_dict[str_key] += f", {str_value}"
+            else:
+                values_dict[str_key] = str_value
+        return values_dict.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return a list of `(key, value)` pairs of headers. Allow multiple
+        occurrences of the same key without concatenating into a single
+        comma separated value.
+        """
+        return [(key.decode(self.encoding), value.decode(self.encoding)) for _, key, value in self._list]
+
+    @typing.overload
+    def get(self, key: str, /) -> str | None: ...
+
+    @typing.overload
+    def get(self, key: str, default: _T) -> str | _T: ...
+
+    def get(self, key: str, default: _T | None = None) -> str | _T | None:
+        """
+        Return a header value. If multiple occurrences of the header occur
+        then concatenate them together with commas.
+        """
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+    def get_list(self, key: str, split_commas: bool = False) -> list[str]:
+        """
+        Return a list of all header values for a given key.
+        If `split_commas=True` is passed, then any comma separated header
+        values are split into multiple return strings.
+        """
+        get_header_key = key.lower().encode(self.encoding)
+
+        values = [
+            item_value.decode(self.encoding)
+            for _, item_key, item_value in self._list
+            if item_key.lower() == get_header_key
+        ]
+
+        if not split_commas:
+            return values
+
+        split_values: list[str] = []
+        for value in values:
+            split_values.extend([item.strip() for item in value.split(",")])
+        return split_values
+
+    def update(self, headers: HeaderTypes | None = None) -> None:  # type: ignore
+        headers = Headers(headers)
+        for key in headers.keys():
+            if key in self:
+                self.pop(key)
+        self._list.extend(headers._list)
+
+    def copy(self) -> Headers:
+        return Headers(self, encoding=self.encoding)
+
+    def __or__(self, other: Mapping[str, str]) -> Headers:
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        merged = self.copy()
+        merged.update(other)
+        return merged
+
+    def __ror__(self, other: Mapping[str, str]) -> Headers:
+        if not isinstance(other, Mapping):
+            return NotImplemented
+        merged = Headers(other)
+        merged.update(self)
+        return merged
+
+    def __ior__(self, other: HeaderTypes) -> Headers:
+        self.update(other)
+        return self
+
+    def __getitem__(self, key: str) -> str:
+        """
+        Return a single header value.
+
+        If there are multiple headers with the same key, then we concatenate
+        them with commas. See: https://tools.ietf.org/html/rfc7230#section-3.2.2
+        """
+        normalized_key = key.lower().encode(self.encoding)
+
+        items = [
+            header_value.decode(self.encoding)
+            for _, header_key, header_value in self._list
+            if header_key == normalized_key
+        ]
+
+        if items:
+            return ", ".join(items)
+
+        raise KeyError(key)
+
+    def __setitem__(self, key: str, value: str) -> None:
+        """
+        Set the header `key` to `value`, removing any duplicate entries.
+        Retains insertion order.
+        """
+        set_key = key.encode(self._encoding or "utf-8")
+        set_value = value.encode(self._encoding or "utf-8")
+        lookup_key = set_key.lower()
+
+        found_indexes = [idx for idx, (_, item_key, _) in enumerate(self._list) if item_key == lookup_key]
+
+        for idx in reversed(found_indexes[1:]):
+            del self._list[idx]
+
+        if found_indexes:
+            idx = found_indexes[0]
+            self._list[idx] = (set_key, lookup_key, set_value)
+        else:
+            self._list.append((set_key, lookup_key, set_value))
+
+    def __delitem__(self, key: str) -> None:
+        """
+        Remove the header `key`.
+        """
+        del_key = key.lower().encode(self.encoding)
+
+        pop_indexes = [idx for idx, (_, item_key, _) in enumerate(self._list) if item_key.lower() == del_key]
+
+        if not pop_indexes:
+            raise KeyError(key)
+
+        for idx in reversed(pop_indexes):
+            del self._list[idx]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        header_key = key.lower().encode(self.encoding)
+        return header_key in [key for _, key, _ in self._list]
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._list)
+
+    def __eq__(self, other: typing.Any) -> bool:
+        try:
+            other_headers = Headers(other)
+        except ValueError:
+            return False
+
+        self_list = [(key, value) for _, key, value in self._list]
+        other_list = [(key, value) for _, key, value in other_headers._list]
+        return sorted(self_list) == sorted(other_list)
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+
+        encoding_str = ""
+        if self.encoding != "ascii":
+            encoding_str = f", encoding={self.encoding!r}"
+
+        as_list = list(_obfuscate_sensitive_headers(self.multi_items()))
+        as_dict = dict(as_list)
+
+        no_duplicate_keys = len(as_dict) == len(as_list)
+        if no_duplicate_keys:
+            return f"{class_name}({as_dict!r}{encoding_str})"
+        return f"{class_name}({as_list!r}{encoding_str})"
+
+
+class Request:
+    def __init__(
+        self,
+        method: str,
+        url: URL | str,
+        *,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        content: RequestContent | None = None,
+        data: RequestData | None = None,
+        files: RequestFiles | None = None,
+        json: typing.Any | None = None,
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        extensions: RequestExtensions | None = None,
+    ) -> None:
+        self.method = method.upper()
+        self.url = URL(url) if params is None else URL(url, params=params)
+        self.headers = Headers(headers)
+        self.extensions = {} if extensions is None else dict(extensions)
+
+        if cookies:
+            Cookies(cookies).set_cookie_header(self)
+
+        if stream is None:
+            content_type: str | None = self.headers.get("content-type")
+            headers, stream = encode_request(
+                content=content,
+                data=data,
+                files=files,
+                json=json,
+                boundary=get_multipart_boundary_from_content_type(
+                    content_type=content_type.encode(self.headers.encoding) if content_type else None
+                ),
+            )
+            self._prepare(headers)
+            self.stream = stream
+            # Load the request body, except for streaming content.
+            if isinstance(stream, ByteStream):
+                self.read()
+        else:
+            # There's an important distinction between `Request(content=...)`,
+            # and `Request(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated `Host` and content
+            # headers, of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include *any*
+            # auto-populated headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when:
+            #
+            # * Preserving the request stream when copying requests, eg for redirects.
+            # * Creating request instances on the *server-side* of the transport API.
+            self.stream = stream
+
+    def _prepare(self, default_headers: dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Content-Length if Transfer-Encoding has been set explicitly.
+            if key.lower() == "content-length" and "Transfer-Encoding" in self.headers:
+                continue
+            # Ignore Transfer-Encoding if Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "Content-Length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+        auto_headers: list[tuple[bytes, bytes]] = []
+
+        has_host = "Host" in self.headers
+        has_content_length = "Content-Length" in self.headers or "Transfer-Encoding" in self.headers
+
+        if not has_host and self.url.host:
+            auto_headers.append((b"Host", self.url.netloc))
+        if not has_content_length and self.method in ("POST", "PUT", "PATCH", "QUERY"):
+            auto_headers.append((b"Content-Length", b"0"))
+
+        self.headers = Headers(auto_headers + self.headers.raw)
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise RequestNotRead()
+        return self._content
+
+    def read(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.Iterable)
+            self._content = b"".join(self.stream)
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the request content.
+        """
+        if not hasattr(self, "_content"):
+            assert isinstance(self.stream, typing.AsyncIterable)
+            self._content = b"".join([part async for part in self.stream])
+            if not isinstance(self.stream, ByteStream):
+                # If a streaming request has been read entirely into memory, then
+                # we can replace the stream with a raw bytes implementation,
+                # to ensure that any non-replayable streams can still be used.
+                self.stream = ByteStream(self._content)
+        return self._content
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        url = str(self.url)
+        return f"<{class_name}({self.method!r}, {url!r})>"
+
+    def __getstate__(self) -> dict[str, typing.Any]:
+        return {name: value for name, value in self.__dict__.items() if name not in ["extensions", "stream"]}
+
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+
+class Response:
+    def __init__(
+        self,
+        status_code: int,
+        *,
+        headers: HeaderTypes | None = None,
+        content: ResponseContent | None = None,
+        text: str | None = None,
+        html: str | None = None,
+        json: typing.Any = None,
+        stream: SyncByteStream | AsyncByteStream | None = None,
+        request: Request | None = None,
+        extensions: ResponseExtensions | None = None,
+        history: list[Response] | None = None,
+        default_encoding: str | typing.Callable[[bytes], str | None] = "utf-8",
+    ) -> None:
+        self.status_code = status_code
+        self.headers = Headers(headers)
+
+        self._request: Request | None = request
+
+        # When follow_redirects=False and a redirect is received,
+        # the client will set `response.next_request`.
+        self.next_request: Request | None = None
+
+        self.extensions = {} if extensions is None else dict(extensions)
+        self.history = [] if history is None else list(history)
+
+        self.is_closed = False
+        self.is_stream_consumed = False
+
+        self.default_encoding = default_encoding
+
+        if stream is None:
+            headers, stream = encode_response(content, text, html, json)
+            self._prepare(headers)
+            self.stream = stream
+            if isinstance(stream, ByteStream):
+                # Load the response body, except for streaming content.
+                self.read()
+        else:
+            # There's an important distinction between `Response(content=...)`,
+            # and `Response(stream=...)`.
+            #
+            # Using `content=...` implies automatically populated content headers,
+            # of either `Content-Length: ...` or `Transfer-Encoding: chunked`.
+            #
+            # Using `stream=...` will not automatically include any content headers.
+            #
+            # As an end-user you don't really need `stream=...`. It's only
+            # useful when creating response instances having received a stream
+            # from the transport API.
+            self.stream = stream
+
+        self._num_bytes_downloaded = 0
+
+    def _prepare(self, default_headers: dict[str, str]) -> None:
+        for key, value in default_headers.items():
+            # Ignore Transfer-Encoding if the Content-Length has been set explicitly.
+            if key.lower() == "transfer-encoding" and "content-length" in self.headers:
+                continue
+            self.headers.setdefault(key, value)
+
+    @property
+    def elapsed(self) -> datetime.timedelta:
+        """
+        Returns the time taken for the complete request/response
+        cycle to complete.
+        """
+        if not hasattr(self, "_elapsed"):
+            stream_elapsed: datetime.timedelta | None = getattr(self.stream, "elapsed", None)
+            if stream_elapsed is not None:
+                return stream_elapsed
+            raise RuntimeError("'.elapsed' may only be accessed after the response has been read or closed.")
+        return self._elapsed
+
+    @elapsed.setter
+    def elapsed(self, elapsed: datetime.timedelta) -> None:
+        self._elapsed = elapsed
+
+    @property
+    def request(self) -> Request:
+        """
+        Returns the request instance associated to the current response.
+        """
+        if self._request is None:
+            raise RuntimeError("The request instance has not been set on this response.")
+        return self._request
+
+    @request.setter
+    def request(self, value: Request) -> None:
+        self._request = value
+
+    @property
+    def http_version(self) -> str:
+        try:
+            http_version: bytes = self.extensions["http_version"]
+        except KeyError:
+            return "HTTP/1.1"
+        else:
+            return http_version.decode("ascii", errors="ignore")
+
+    @property
+    def reason_phrase(self) -> str:
+        try:
+            reason_phrase: bytes = self.extensions["reason_phrase"]
+        except KeyError:
+            return codes.get_reason_phrase(self.status_code)
+        else:
+            return reason_phrase.decode("ascii", errors="ignore")
+
+    @property
+    def url(self) -> URL:
+        """
+        Returns the URL for which the request was made.
+        """
+        return self.request.url
+
+    @property
+    def content(self) -> bytes:
+        if not hasattr(self, "_content"):
+            raise ResponseNotRead()
+        return self._content
+
+    @property
+    def text(self) -> str:
+        if not hasattr(self, "_text"):
+            content = self.content
+            if not content:
+                self._text = ""
+            else:
+                decoder = TextDecoder(encoding=self.encoding or "utf-8")
+                self._text = "".join([decoder.decode(self.content), decoder.flush()])
+        return self._text
+
+    @property
+    def encoding(self) -> str | None:
+        """
+        Return an encoding to use for decoding the byte content into text.
+        The priority for determining this is given by...
+
+        * `.encoding = <>` has been set explicitly.
+        * The encoding as specified by the charset parameter in the Content-Type header.
+        * The encoding as determined by `default_encoding`, which may either be
+          a string like "utf-8" indicating the encoding to use, or may be a callable
+          which enables charset autodetection.
+        """
+        if not hasattr(self, "_encoding"):
+            encoding = self.charset_encoding
+            if encoding is None or not _is_known_encoding(encoding):
+                if isinstance(self.default_encoding, str):
+                    encoding = self.default_encoding
+                elif hasattr(self, "_content"):
+                    encoding = self.default_encoding(self._content)
+            self._encoding = encoding or "utf-8"
+        return self._encoding
+
+    @encoding.setter
+    def encoding(self, value: str) -> None:
+        """
+        Set the encoding to use for decoding the byte content into text.
+
+        If the `text` attribute has been accessed, attempting to set the
+        encoding will throw a ValueError.
+        """
+        if hasattr(self, "_text"):
+            raise ValueError("Setting encoding after `text` has been accessed is not allowed.")
+        self._encoding = value
+
+    @property
+    def charset_encoding(self) -> str | None:
+        """
+        Return the encoding, as specified by the Content-Type header.
+        """
+        content_type = self.headers.get("Content-Type")
+        if content_type is None:
+            return None
+
+        return _parse_content_type_charset(content_type)
+
+    def _get_content_decoder(self) -> ContentDecoder:
+        """
+        Returns a decoder instance which can be used to decode the raw byte
+        content, depending on the Content-Encoding used in the response.
+        """
+        if not hasattr(self, "_decoder"):
+            values = self.headers.get_list("content-encoding", split_commas=True)
+            encodings = [value.strip().lower() for value in values]
+            decoder = MultiDecoder([encoding for encoding in encodings if encoding != "identity"])
+            if len(decoder.children) == 1:
+                self._decoder = decoder.children[0]
+            elif decoder.children:
+                self._decoder = decoder
+            else:
+                self._decoder = IdentityDecoder()
+
+        return self._decoder
+
+    @property
+    def is_informational(self) -> bool:
+        """
+        A property which is `True` for 1xx status codes, `False` otherwise.
+        """
+        return codes.is_informational(self.status_code)
+
+    @property
+    def is_success(self) -> bool:
+        """
+        A property which is `True` for 2xx status codes, `False` otherwise.
+        """
+        return codes.is_success(self.status_code)
+
+    @property
+    def is_redirect(self) -> bool:
+        """
+        A property which is `True` for 3xx status codes, `False` otherwise.
+
+        Note that not all responses with a 3xx status code indicate a URL redirect.
+
+        Use `response.has_redirect_location` to determine responses with a properly
+        formed URL redirection.
+        """
+        return codes.is_redirect(self.status_code)
+
+    @property
+    def is_client_error(self) -> bool:
+        """
+        A property which is `True` for 4xx status codes, `False` otherwise.
+        """
+        return codes.is_client_error(self.status_code)
+
+    @property
+    def is_server_error(self) -> bool:
+        """
+        A property which is `True` for 5xx status codes, `False` otherwise.
+        """
+        return codes.is_server_error(self.status_code)
+
+    @property
+    def is_error(self) -> bool:
+        """
+        A property which is `True` for 4xx and 5xx status codes, `False` otherwise.
+        """
+        return codes.is_error(self.status_code)
+
+    @property
+    def has_redirect_location(self) -> bool:
+        """
+        Returns True for 3xx responses with a properly formed URL redirection,
+        `False` otherwise.
+        """
+        return (
+            self.status_code
+            in (
+                # 301 (Cacheable redirect. Method may change to GET.)
+                codes.MOVED_PERMANENTLY,
+                # 302 (Uncacheable redirect. Method may change to GET.)
+                codes.FOUND,
+                # 303 (Client should make a GET or HEAD request.)
+                codes.SEE_OTHER,
+                # 307 (Equiv. 302, but retain method)
+                codes.TEMPORARY_REDIRECT,
+                # 308 (Equiv. 301, but retain method)
+                codes.PERMANENT_REDIRECT,
+            )
+            and "Location" in self.headers
+        )
+
+    def raise_for_status(self) -> Response:
+        """
+        Raise the `HTTPStatusError` if one occurred.
+        """
+        request = self._request
+        if request is None:
+            raise RuntimeError(
+                "Cannot call `raise_for_status` as the request instance has not been set on this response."
+            )
+
+        if self.is_success:
+            return self
+
+        if self.has_redirect_location:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "Redirect location: '{0.headers[location]}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+        else:
+            message = (
+                "{error_type} '{0.status_code} {0.reason_phrase}' for url '{0.url}'\n"
+                "For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/{0.status_code}"
+            )
+
+        status_class = self.status_code // 100
+        error_types = {
+            1: "Informational response",
+            3: "Redirect response",
+            4: "Client error",
+            5: "Server error",
+        }
+        error_type = error_types.get(status_class, "Invalid status code")
+        message = message.format(self, error_type=error_type)
+        raise HTTPStatusError(message, request=request, response=self)
+
+    def json(self, **kwargs: typing.Any) -> typing.Any:
+        return jsonlib.loads(self.content, **kwargs)
+
+    @property
+    def cookies(self) -> Cookies:
+        if not hasattr(self, "_cookies"):
+            self._cookies = Cookies()
+            self._cookies.extract_cookies(self)
+        return self._cookies
+
+    @property
+    def links(self) -> dict[str | None, dict[str, str]]:
+        """
+        Returns the parsed header links of the response, if any
+        """
+        header = self.headers.get("link")
+        if header is None:
+            return {}
+
+        return {(link.get("rel") or link.get("url")): link for link in _parse_header_links(header)}
+
+    @property
+    def num_bytes_downloaded(self) -> int:
+        return self._num_bytes_downloaded
+
+    def __repr__(self) -> str:
+        return f"<Response [{self.status_code} {self.reason_phrase}]>"
+
+    def __getstate__(self) -> dict[str, typing.Any]:
+        return {
+            name: value
+            for name, value in self.__dict__.items()
+            if name not in ["extensions", "stream", "is_closed", "_decoder"]
+        }
+
+    def __setstate__(self, state: dict[str, typing.Any]) -> None:
+        for name, value in state.items():
+            setattr(self, name, value)
+        self.is_closed = True
+        self.extensions = {}
+        self.stream = UnattachedStream()
+
+    def read(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            self._content = b"".join(self.iter_bytes())
+        return self._content
+
+    def iter_bytes(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                for raw_bytes in self.iter_raw():
+                    for decoded in decoder.decode(raw_bytes):
+                        for chunk in chunker.decode(decoded):
+                            yield chunk
+                for decoded in decoder.flush():
+                    for chunk in chunker.decode(decoded):
+                        yield chunk  # pragma: no cover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    def iter_text(self, chunk_size: int | None = None) -> typing.Iterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            for byte_content in self.iter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk  # pragma: no cover
+            for chunk in chunker.flush():
+                yield chunk
+
+    def iter_lines(self) -> typing.Iterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            for text in self.iter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    def iter_raw(self, chunk_size: int | None = None) -> typing.Iterator[bytes]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call a sync iterator on an async stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        try:
+            with request_context(request=self._request):
+                for raw_stream_bytes in self.stream:
+                    self._num_bytes_downloaded += len(raw_stream_bytes)
+                    for chunk in chunker.decode(raw_stream_bytes):
+                        yield chunk
+
+            for chunk in chunker.flush():
+                yield chunk
+        finally:
+            self.close()
+
+    def close(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, SyncByteStream):
+            raise RuntimeError("Attempted to call a sync close on an async stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                self.stream.close()
+
+    async def aread(self) -> bytes:
+        """
+        Read and return the response content.
+        """
+        if not hasattr(self, "_content"):
+            async with contextlib.aclosing(self.aiter_bytes()) as parts:
+                self._content = b"".join([part async for part in parts])
+        return self._content
+
+    async def aiter_bytes(self, chunk_size: int | None = None) -> typing.AsyncGenerator[bytes, None]:
+        """
+        A byte-iterator over the decoded response content.
+        This allows us to handle gzip, deflate, brotli, and zstd encoded responses.
+        """
+        if hasattr(self, "_content"):
+            chunk_size = len(self._content) if chunk_size is None else chunk_size
+            for i in range(0, len(self._content), max(chunk_size, 1)):
+                yield self._content[i : i + chunk_size]
+        else:
+            decoder = self._get_content_decoder()
+            chunker = ByteChunker(chunk_size=chunk_size)
+            with request_context(request=self._request):
+                async with contextlib.aclosing(self.aiter_raw()) as raw_stream:
+                    async for raw_bytes in raw_stream:
+                        for decoded in decoder.decode(raw_bytes):
+                            for chunk in chunker.decode(decoded):
+                                yield chunk
+                for decoded in decoder.flush():
+                    for chunk in chunker.decode(decoded):
+                        yield chunk  # pragma: no cover
+                for chunk in chunker.flush():
+                    yield chunk
+
+    async def aiter_text(self, chunk_size: int | None = None) -> typing.AsyncIterator[str]:
+        """
+        A str-iterator over the decoded response content
+        that handles both gzip, deflate, etc but also detects the content's
+        string encoding.
+        """
+        decoder = TextDecoder(encoding=self.encoding or "utf-8")
+        chunker = TextChunker(chunk_size=chunk_size)
+        with request_context(request=self._request):
+            async for byte_content in self.aiter_bytes():
+                text_content = decoder.decode(byte_content)
+                for chunk in chunker.decode(text_content):
+                    yield chunk
+            text_content = decoder.flush()
+            for chunk in chunker.decode(text_content):
+                yield chunk  # pragma: no cover
+            for chunk in chunker.flush():
+                yield chunk
+
+    async def aiter_lines(self) -> typing.AsyncIterator[str]:
+        decoder = LineDecoder()
+        with request_context(request=self._request):
+            async for text in self.aiter_text():
+                for line in decoder.decode(text):
+                    yield line
+            for line in decoder.flush():
+                yield line
+
+    async def aiter_raw(self, chunk_size: int | None = None) -> typing.AsyncGenerator[bytes, None]:
+        """
+        A byte-iterator over the raw response content.
+        """
+        if self.is_stream_consumed:
+            raise StreamConsumed()
+        if self.is_closed:
+            raise StreamClosed()
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async iterator on a sync stream.")
+
+        self.is_stream_consumed = True
+        self._num_bytes_downloaded = 0
+        chunker = ByteChunker(chunk_size=chunk_size)
+
+        stream = self.stream.__aiter__()
+        try:
+            with request_context(request=self._request):
+                async for raw_stream_bytes in stream:
+                    self._num_bytes_downloaded += len(raw_stream_bytes)
+                    for chunk in chunker.decode(raw_stream_bytes):
+                        yield chunk
+
+            for chunk in chunker.flush():
+                yield chunk
+        finally:
+            if isinstance(stream, AsyncGenerator):
+                await stream.aclose()
+            await self.aclose()
+
+    async def aclose(self) -> None:
+        """
+        Close the response and release the connection.
+        Automatically called if the response body is read to completion.
+        """
+        if not isinstance(self.stream, AsyncByteStream):
+            raise RuntimeError("Attempted to call an async close on a sync stream.")
+
+        if not self.is_closed:
+            self.is_closed = True
+            with request_context(request=self._request):
+                await self.stream.aclose()
+
+
+class Cookies(typing.MutableMapping[str, str]):
+    """
+    HTTP Cookies, as a mutable mapping.
+    """
+
+    def __init__(self, cookies: CookieTypes | None = None) -> None:
+        if cookies is None or isinstance(cookies, dict):
+            self.jar = CookieJar()
+            if isinstance(cookies, dict):
+                for key, value in cookies.items():
+                    self.set(key, value)
+        elif isinstance(cookies, list):
+            self.jar = CookieJar()
+            for key, value in cookies:
+                self.set(key, value)
+        elif isinstance(cookies, Cookies):
+            self.jar = CookieJar()
+            for cookie in cookies.jar:
+                self.jar.set_cookie(cookie)
+        else:
+            self.jar = cookies
+
+    def extract_cookies(self, response: Response) -> None:
+        """
+        Loads any cookies based on the response `Set-Cookie` headers.
+        """
+        if "set-cookie" not in response.headers and "set-cookie2" not in response.headers:
+            return
+
+        urllib_response = self._CookieCompatResponse(response)
+        urllib_request = self._CookieCompatRequest(response.request)
+
+        self.jar.extract_cookies(urllib_response, urllib_request)  # type: ignore
+
+    def set_cookie_header(self, request: Request) -> None:
+        """
+        Sets an appropriate 'Cookie:' HTTP header on the `Request`.
+        """
+        urllib_request = self._CookieCompatRequest(request)
+        self.jar.add_cookie_header(urllib_request)
+
+    def set(self, name: str, value: str, domain: str = "", path: str = "/") -> None:
+        """
+        Set a cookie value by name. May optionally include domain and path.
+        """
+        kwargs = {
+            "version": 0,
+            "name": name,
+            "value": value,
+            "port": None,
+            "port_specified": False,
+            "domain": domain,
+            "domain_specified": bool(domain),
+            "domain_initial_dot": domain.startswith("."),
+            "path": path,
+            "path_specified": bool(path),
+            "secure": False,
+            "expires": None,
+            "discard": True,
+            "comment": None,
+            "comment_url": None,
+            "rest": {"HttpOnly": None},
+            "rfc2109": False,
+        }
+        cookie = Cookie(**kwargs)  # type: ignore
+        self.jar.set_cookie(cookie)
+
+    def get(  # type: ignore
+        self,
+        name: str,
+        default: str | None = None,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> str | None:
+        """
+        Get a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to retrieve.
+        """
+        value = None
+        for cookie in self.jar:
+            if cookie.name == name:
+                if domain is None or cookie.domain == domain:
+                    if path is None or cookie.path == path:
+                        if value is not None:
+                            message = f"Multiple cookies exist with name={name}"
+                            raise CookieConflict(message)
+                        value = cookie.value
+
+        if value is None:
+            return default
+        return value
+
+    def delete(
+        self,
+        name: str,
+        domain: str | None = None,
+        path: str | None = None,
+    ) -> None:
+        """
+        Delete a cookie by name. May optionally include domain and path
+        in order to specify exactly which cookie to delete.
+        """
+        if domain is not None and path is not None:
+            return self.jar.clear(domain, path, name)
+
+        remove = [
+            cookie
+            for cookie in self.jar
+            if cookie.name == name
+            and (domain is None or cookie.domain == domain)
+            and (path is None or cookie.path == path)
+        ]
+
+        for cookie in remove:
+            self.jar.clear(cookie.domain, cookie.path, cookie.name)
+
+    def clear(self, domain: str | None = None, path: str | None = None) -> None:
+        """
+        Delete all cookies. Optionally include a domain and path in
+        order to only delete a subset of all the cookies.
+        """
+        args: list[str] = []
+        if domain is not None:
+            args.append(domain)
+        if path is not None:
+            assert domain is not None
+            args.append(path)
+        self.jar.clear(*args)
+
+    def update(self, cookies: CookieTypes | None = None) -> None:  # type: ignore
+        cookies = Cookies(cookies)
+        for cookie in cookies.jar:
+            self.jar.set_cookie(cookie)
+
+    def __setitem__(self, name: str, value: str) -> None:
+        return self.set(name, value)
+
+    def __getitem__(self, name: str) -> str:
+        value = self.get(name)
+        if value is None:
+            raise KeyError(name)
+        return value
+
+    def __delitem__(self, name: str) -> None:
+        return self.delete(name)
+
+    def __len__(self) -> int:
+        return len(self.jar)
+
+    def __iter__(self) -> typing.Iterator[str]:
+        return (cookie.name for cookie in self.jar)
+
+    def __bool__(self) -> bool:
+        for _ in self.jar:
+            return True
+        return False
+
+    def __repr__(self) -> str:
+        cookies_repr = ", ".join(
+            [f"<Cookie {cookie.name}={cookie.value} for {cookie.domain} />" for cookie in self.jar]
+        )
+
+        return f"<Cookies[{cookies_repr}]>"
+
+    class _CookieCompatRequest(urllib.request.Request):
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, request: Request) -> None:
+            super().__init__(
+                url=str(request.url),
+                headers=dict(request.headers),
+                method=request.method,
+            )
+            self.request = request
+
+        def add_unredirected_header(self, key: str, val: str) -> None:
+            super().add_unredirected_header(key, val)
+            self.request.headers[key] = val
+
+    class _CookieCompatResponse:
+        """
+        Wraps a `Request` instance up in a compatibility interface suitable
+        for use with `CookieJar` operations.
+        """
+
+        def __init__(self, response: Response) -> None:
+            self.response = response
+
+        def info(self) -> email.message.Message:
+            info = email.message.Message()
+            for key, value in self.response.headers.multi_items():
+                # Note that setting `info[key]` here is an "append" operation,
+                # not a "replace" operation.
+                # https://docs.python.org/3/library/email.compat32-message.html#email.message.Message.__setitem__
+                info[key] = value
+            return info
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_multipart.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_multipart.py
new file mode 100644
index 0000000000000000000000000000000000000000..2c65610579eaae8a99b7b1790185e5ed5284a7ed
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_multipart.py
@@ -0,0 +1,284 @@
+from __future__ import annotations
+
+import io
+import mimetypes
+import os
+import re
+import typing
+from pathlib import Path
+
+from ._types import (
+    AsyncByteStream,
+    FileContent,
+    FileTypes,
+    RequestData,
+    RequestFiles,
+    SyncByteStream,
+)
+from ._utils import (
+    peek_filelike_length,
+    primitive_value_to_str,
+    to_bytes,
+)
+
+_HTML5_FORM_ENCODING_REPLACEMENTS = {'"': "%22", "\\": "\\\\"}
+_HTML5_FORM_ENCODING_REPLACEMENTS.update({chr(c): f"%{c:02X}" for c in range(0x1F + 1) if c != 0x1B})
+_HTML5_FORM_ENCODING_RE = re.compile(r"|".join([re.escape(c) for c in _HTML5_FORM_ENCODING_REPLACEMENTS.keys()]))
+_HEADER_NAME_RE = re.compile(r"[!#$%&'*+\-.^_`|~0-9A-Za-z]+")
+_FORBIDDEN_HEADER_VALUE_CHARS_RE = re.compile(r"[\x00-\x08\x0a-\x1f\x7f]")
+
+
+def _format_form_param(name: str, value: str) -> bytes:
+    """
+    Encode a name/value pair within a multipart form.
+    """
+
+    def replacer(match: typing.Match[str]) -> str:
+        return _HTML5_FORM_ENCODING_REPLACEMENTS[match.group(0)]
+
+    value = _HTML5_FORM_ENCODING_RE.sub(replacer, value)
+    return f'{name}="{value}"'.encode()
+
+
+def _guess_content_type(filename: str | None) -> str | None:
+    """
+    Guesses the mimetype based on a filename. Defaults to `application/octet-stream`.
+
+    Returns `None` if `filename` is `None` or empty.
+    """
+    if filename:
+        return mimetypes.guess_type(filename)[0] or "application/octet-stream"
+    return None
+
+
+def get_multipart_boundary_from_content_type(
+    content_type: bytes | None,
+) -> bytes | None:
+    if not content_type or not content_type.startswith(b"multipart/form-data"):
+        return None
+    # parse boundary according to
+    # https://www.rfc-editor.org/rfc/rfc2046#section-5.1.1
+    if b";" in content_type:
+        for section in content_type.split(b";"):
+            if section.strip().lower().startswith(b"boundary="):
+                return section.strip()[len(b"boundary=") :].strip(b'"')
+    return None
+
+
+class DataField:
+    """
+    A single form field item, within a multipart form field.
+    """
+
+    def __init__(self, name: str, value: str | bytes | int | float | None) -> None:
+        if not isinstance(name, str):
+            raise TypeError(f"Invalid type for name. Expected str, got {type(name)}: {name!r}")
+        if value is not None and not isinstance(value, (str, bytes, int, float)):
+            raise TypeError(f"Invalid type for value. Expected primitive type, got {type(value)}: {value!r}")
+        self.name = name
+        self.value: str | bytes = value if isinstance(value, bytes) else primitive_value_to_str(value)
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            name = _format_form_param("name", self.name)
+            self._headers = b"".join([b"Content-Disposition: form-data; ", name, b"\r\n\r\n"])
+
+        return self._headers
+
+    def render_data(self) -> bytes:
+        if not hasattr(self, "_data"):
+            self._data = to_bytes(self.value)
+
+        return self._data
+
+    def get_length(self) -> int:
+        headers = self.render_headers()
+        data = self.render_data()
+        return len(headers) + len(data)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield self.render_data()
+
+
+class FileField:
+    """
+    A single file field item, within a multipart form field.
+    """
+
+    CHUNK_SIZE = 64 * 1024
+
+    def __init__(self, name: str, value: FileTypes) -> None:
+        self.name = name
+
+        fileobj: FileContent
+
+        headers: dict[str, str] = {}
+        content_type: str | None = None
+
+        # This large tuple based API largely mirror's requests' API
+        # It would be good to think of better APIs for this that we could
+        # include in httpx 2.0 since variable length tuples(especially of 4 elements)
+        # are quite unwieldy
+        if isinstance(value, tuple):
+            if len(value) == 2:
+                # neither the 3rd parameter (content_type) nor the 4th (headers)
+                # was included
+                filename, fileobj = value
+            elif len(value) == 3:
+                filename, fileobj, content_type = value
+            else:
+                # all 4 parameters included
+                filename, fileobj, content_type, headers = value  # type: ignore
+        else:
+            filename = Path(str(getattr(value, "name", "upload"))).name
+            fileobj = value
+
+        if content_type is None:
+            content_type = _guess_content_type(filename)
+
+        has_content_type_header = any("content-type" in key.lower() for key in headers)
+        if content_type is not None and not has_content_type_header:
+            # note that unlike requests, we ignore the content_type provided in the 3rd
+            # tuple element if it is also included in the headers requests does
+            # the opposite (it overwrites the headerwith the 3rd tuple element)
+            headers["Content-Type"] = content_type
+
+        if isinstance(fileobj, io.StringIO):
+            raise TypeError("Multipart file uploads require 'io.BytesIO', not 'io.StringIO'.")
+        if isinstance(fileobj, io.TextIOBase):
+            raise TypeError("Multipart file uploads must be opened in binary mode, not text mode.")
+
+        self.filename = filename
+        self.file = fileobj
+        self.headers = headers
+
+    def get_length(self) -> int | None:
+        headers = self.render_headers()
+
+        if isinstance(self.file, (str, bytes)):
+            return len(headers) + len(to_bytes(self.file))
+
+        file_length = peek_filelike_length(self.file)
+
+        # If we can't determine the filesize without reading it into memory,
+        # then return `None` here, to indicate an unknown file length.
+        if file_length is None:
+            return None
+
+        return len(headers) + file_length
+
+    def render_headers(self) -> bytes:
+        if not hasattr(self, "_headers"):
+            parts = [
+                b"Content-Disposition: form-data; ",
+                _format_form_param("name", self.name),
+            ]
+            if self.filename:
+                filename = _format_form_param("filename", self.filename)
+                parts.extend([b"; ", filename])
+            for header_name, header_value in self.headers.items():
+                if _HEADER_NAME_RE.fullmatch(header_name) is None:
+                    raise ValueError("Invalid multipart header name.")
+                if _FORBIDDEN_HEADER_VALUE_CHARS_RE.search(header_value) is not None:
+                    raise ValueError("Invalid control character in multipart header value.")
+                key, val = f"\r\n{header_name}: ".encode(), header_value.encode()
+                parts.extend([key, val])
+            parts.append(b"\r\n\r\n")
+            self._headers = b"".join(parts)
+
+        return self._headers
+
+    def render_data(self) -> typing.Iterator[bytes]:
+        if isinstance(self.file, (str, bytes)):
+            yield to_bytes(self.file)
+            return
+
+        if hasattr(self.file, "seek"):
+            try:
+                self.file.seek(0)
+            except io.UnsupportedOperation:
+                pass
+
+        chunk = self.file.read(self.CHUNK_SIZE)
+        while chunk:
+            yield to_bytes(chunk)
+            chunk = self.file.read(self.CHUNK_SIZE)
+
+    def render(self) -> typing.Iterator[bytes]:
+        yield self.render_headers()
+        yield from self.render_data()
+
+
+class MultipartStream(SyncByteStream, AsyncByteStream):
+    """
+    Request content as streaming multipart encoded form data.
+    """
+
+    def __init__(
+        self,
+        data: RequestData,
+        files: RequestFiles,
+        boundary: bytes | None = None,
+    ) -> None:
+        if boundary is None:
+            boundary = os.urandom(16).hex().encode("ascii")
+
+        self.boundary = boundary
+        self.content_type = f"multipart/form-data; boundary={boundary.decode('ascii')}"
+        self.fields = list(self._iter_fields(data, files))
+
+    def _iter_fields(self, data: RequestData, files: RequestFiles) -> typing.Iterator[FileField | DataField]:
+        for name, value in data.items():
+            if isinstance(value, (tuple, list)):
+                for item in value:
+                    yield DataField(name=name, value=item)
+            else:
+                yield DataField(name=name, value=value)
+
+        file_items = files.items() if isinstance(files, typing.Mapping) else files
+        for name, value in file_items:
+            yield FileField(name=name, value=value)
+
+    def iter_chunks(self) -> typing.Iterator[bytes]:
+        for field in self.fields:
+            yield b"--%s\r\n" % self.boundary
+            yield from field.render()
+            yield b"\r\n"
+        yield b"--%s--\r\n" % self.boundary
+
+    def get_content_length(self) -> int | None:
+        """
+        Return the length of the multipart encoded content, or `None` if
+        any of the files have a length that cannot be determined upfront.
+        """
+        boundary_length = len(self.boundary)
+        length = 0
+
+        for field in self.fields:
+            field_length = field.get_length()
+            if field_length is None:
+                return None
+
+            length += 2 + boundary_length + 2  # b"--{boundary}\r\n"
+            length += field_length
+            length += 2  # b"\r\n"
+
+        length += 2 + boundary_length + 4  # b"--{boundary}--\r\n"
+        return length
+
+    # Content stream interface.
+
+    def get_headers(self) -> dict[str, str]:
+        content_length = self.get_content_length()
+        content_type = self.content_type
+        if content_length is None:
+            return {"Transfer-Encoding": "chunked", "Content-Type": content_type}
+        return {"Content-Length": str(content_length), "Content-Type": content_type}
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        yield from self.iter_chunks()
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        for chunk in self.iter_chunks():
+            yield chunk
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_sse.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_sse.py
new file mode 100644
index 0000000000000000000000000000000000000000..df2be6aa62515ff301bf8792c78c435c3224c5f5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_sse.py
@@ -0,0 +1,226 @@
+"""
+Server-sent events support, derived from httpx-sse (https://github.com/florimondmanca/httpx-sse).
+
+```
+MIT License
+
+Copyright (c) 2022 Florimond Manca
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+"""
+
+from __future__ import annotations
+
+import json as jsonlib
+from collections.abc import AsyncIterator, Iterator
+from dataclasses import dataclass
+
+from ._config import DEFAULT_MAX_EVENT_SIZE_BYTES
+from ._exceptions import TransportError, request_context
+from ._models import Response
+
+__all__ = ["EventSource", "SSEError", "ServerSentEvent"]
+
+
+class SSEError(TransportError):
+    """
+    An error that occurred while connecting to a server-sent events endpoint.
+    """
+
+
+@dataclass(frozen=True)
+class ServerSentEvent:
+    event: str = "message"
+    data: str = ""
+    id: str = ""
+    retry: int | None = None
+
+    def json(self) -> object:
+        return jsonlib.loads(self.data)
+
+
+class _SSEEventDecoder:
+    def __init__(self, max_event_size: int | None = None) -> None:
+        self._max_event_size = max_event_size
+        self._event = ""
+        self._data: list[str] = []
+        self._event_size = 0
+        self._last_event_id = ""
+        self._retry: int | None = None
+        self._pending = False
+
+    def decode(self, line: str) -> ServerSentEvent | None:
+        if not line:
+            self._event_size = 0
+            if not self._pending:
+                return None
+
+            sse = ServerSentEvent(
+                event=self._event or "message",
+                data="\n".join(self._data),
+                id=self._last_event_id,
+                retry=self._retry,
+            )
+            self._event = ""
+            self._data = []
+            self._retry = None
+            self._pending = False
+            return sse
+
+        if line.startswith(":"):
+            return None
+
+        self._event_size += len(line.encode("utf-8"))
+        self._check_size()
+
+        fieldname, _, value = line.partition(":")
+        value = value[1:] if value.startswith(" ") else value
+
+        if fieldname == "event":
+            self._event = value
+            self._pending = True
+        elif fieldname == "data":
+            self._data.append(value)
+            self._pending = True
+        elif fieldname == "id":
+            if "\0" not in value:
+                self._last_event_id = value
+                self._pending = True
+        elif fieldname == "retry":
+            try:
+                self._retry = int(value)
+                self._pending = True
+            except ValueError:
+                pass
+
+        return None
+
+    def check_pending(self, pending_size: int) -> None:
+        """
+        Bound the total bytes buffered for the in-progress event, including
+        a trailing line that has not been terminated by a newline yet.
+        """
+        self._check_size(pending_size)
+
+    def _check_size(self, pending_size: int = 0) -> None:
+        if self._max_event_size is not None and self._event_size + pending_size > self._max_event_size:
+            raise SSEError(f"Server-sent event exceeded the {self._max_event_size} byte limit.")
+
+
+class _SSELineDecoder:
+    def __init__(self) -> None:
+        self._parts: list[str] = []
+        self._pending_size = 0
+        self._trailing_cr = False
+
+    @property
+    def pending_size(self) -> int:
+        return self._pending_size
+
+    def decode(self, text: str) -> list[str]:
+        if self._trailing_cr:
+            text = "\r" + text
+            self._trailing_cr = False
+        if text.endswith("\r"):
+            self._trailing_cr = True
+            text = text[:-1]
+
+        text = text.replace("\r\n", "\n").replace("\r", "\n")
+        if "\n" not in text:
+            self._append(text)
+            return []
+
+        lines = text.split("\n")
+        self._append(lines[0])
+        lines[0] = self._consume_pending()
+        self._append(lines.pop())
+        return lines
+
+    def flush(self) -> list[str]:
+        if self._trailing_cr:
+            self._append("\n")
+            self._trailing_cr = False
+        buffer = self._consume_pending()
+        if not buffer:
+            return []
+        return buffer.split("\n")
+
+    def _append(self, text: str) -> None:
+        if text:
+            self._parts.append(text)
+            self._pending_size += len(text.encode("utf-8"))
+
+    def _consume_pending(self) -> str:
+        pending = "".join(self._parts)
+        self._parts = []
+        self._pending_size = 0
+        return pending
+
+
+class _SSEParser:
+    def __init__(self, max_event_size: int | None = None) -> None:
+        self._event_decoder = _SSEEventDecoder(max_event_size)
+        self._line_decoder = _SSELineDecoder()
+
+    def decode(self, text: str) -> Iterator[ServerSentEvent]:
+        yield from self._decode_lines(self._line_decoder.decode(text))
+        self._event_decoder.check_pending(self._line_decoder.pending_size)
+
+    def flush(self) -> Iterator[ServerSentEvent]:
+        yield from self._decode_lines(self._line_decoder.flush())
+
+    def _decode_lines(self, lines: list[str]) -> Iterator[ServerSentEvent]:
+        for line in lines:
+            sse = self._event_decoder.decode(line)
+            if sse is not None:
+                yield sse
+
+
+class EventSource:
+    def __init__(self, response: Response, max_event_size: int | None = DEFAULT_MAX_EVENT_SIZE_BYTES) -> None:
+        self._response = response
+        self._max_event_size = max_event_size
+
+    @property
+    def response(self) -> Response:
+        return self._response
+
+    def _check_content_type(self) -> None:
+        content_type, _, _ = self._response.headers.get("content-type", "").partition(";")
+        if content_type.strip().lower() != "text/event-stream":
+            raise SSEError(f"Expected response with content type 'text/event-stream', got {content_type.strip()!r}.")
+
+    def __iter__(self) -> Iterator[ServerSentEvent]:
+        with request_context(request=self._response.request):
+            self._check_content_type()
+            parser = _SSEParser(self._max_event_size)
+            for chunk in self._response.iter_text():
+                yield from parser.decode(chunk)
+            yield from parser.flush()
+
+    async def __aiter__(self) -> AsyncIterator[ServerSentEvent]:
+        with request_context(request=self._response.request):
+            self._check_content_type()
+            parser = _SSEParser(self._max_event_size)
+            async for chunk in self._response.aiter_text():
+                for sse in parser.decode(chunk):
+                    yield sse
+            for sse in parser.flush():
+                yield sse
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_status_codes.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_status_codes.py
new file mode 100644
index 0000000000000000000000000000000000000000..8afc6a92d433ff174f3451e7a749b27e41260a0b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_status_codes.py
@@ -0,0 +1,189 @@
+from __future__ import annotations
+
+import warnings
+from enum import EnumMeta, IntEnum
+
+__all__ = ["codes"]
+
+# Constant names that were renamed by RFC 9110, kept as deprecated aliases
+# mapping each old name to its canonical replacement.
+_DEPRECATED_CODES = {
+    "REQUEST_ENTITY_TOO_LARGE": "CONTENT_TOO_LARGE",
+    "REQUEST_URI_TOO_LONG": "URI_TOO_LONG",
+    "REQUESTED_RANGE_NOT_SATISFIABLE": "RANGE_NOT_SATISFIABLE",
+    "UNPROCESSABLE_ENTITY": "UNPROCESSABLE_CONTENT",
+}
+
+
+class _CodesMeta(EnumMeta):
+    def __getattribute__(cls, name: str) -> object:
+        if name in _DEPRECATED_CODES:
+            new_name = _DEPRECATED_CODES[name]
+            warnings.warn(
+                f"'{name}' is deprecated. Use '{new_name}' instead.",
+                category=DeprecationWarning,
+                stacklevel=2,
+            )
+        return super().__getattribute__(name)
+
+
+class codes(IntEnum, metaclass=_CodesMeta):
+    """HTTP status codes and reason phrases
+
+    Status codes from the following RFCs are all observed:
+
+        * RFC 9110: HTTP Semantics, obsoletes 7231 & 7238
+        * RFC 6585: Additional HTTP Status Codes
+        * RFC 3229: Delta encoding in HTTP
+        * RFC 4918: HTTP Extensions for WebDAV, obsoletes 2518
+        * RFC 5842: Binding Extensions to WebDAV
+        * RFC 2295: Transparent Content Negotiation in HTTP
+        * RFC 2774: An HTTP Extension Framework
+        * RFC 7540: Hypertext Transfer Protocol Version 2 (HTTP/2)
+        * RFC 2324: Hyper Text Coffee Pot Control Protocol (HTCPCP/1.0)
+        * RFC 7725: An HTTP Status Code to Report Legal Obstacles
+        * RFC 8297: An HTTP Status Code for Indicating Hints
+        * RFC 8470: Using Early Data in HTTP
+    """
+
+    def __new__(cls, value: int, phrase: str = "") -> codes:
+        obj = int.__new__(cls, value)
+        obj._value_ = value
+
+        obj.phrase = phrase  # type: ignore[attr-defined]
+        return obj
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    @classmethod
+    def get_reason_phrase(cls, value: int) -> str:
+        try:
+            return codes(value).phrase  # type: ignore
+        except ValueError:
+            return ""
+
+    @classmethod
+    def is_informational(cls, value: int) -> bool:
+        """
+        Returns `True` for 1xx status codes, `False` otherwise.
+        """
+        return 100 <= value <= 199
+
+    @classmethod
+    def is_success(cls, value: int) -> bool:
+        """
+        Returns `True` for 2xx status codes, `False` otherwise.
+        """
+        return 200 <= value <= 299
+
+    @classmethod
+    def is_redirect(cls, value: int) -> bool:
+        """
+        Returns `True` for 3xx status codes, `False` otherwise.
+        """
+        return 300 <= value <= 399
+
+    @classmethod
+    def is_client_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 499
+
+    @classmethod
+    def is_server_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 5xx status codes, `False` otherwise.
+        """
+        return 500 <= value <= 599
+
+    @classmethod
+    def is_error(cls, value: int) -> bool:
+        """
+        Returns `True` for 4xx or 5xx status codes, `False` otherwise.
+        """
+        return 400 <= value <= 599
+
+    # informational
+    CONTINUE = 100, "Continue"
+    SWITCHING_PROTOCOLS = 101, "Switching Protocols"
+    PROCESSING = 102, "Processing"
+    EARLY_HINTS = 103, "Early Hints"
+
+    # success
+    OK = 200, "OK"
+    CREATED = 201, "Created"
+    ACCEPTED = 202, "Accepted"
+    NON_AUTHORITATIVE_INFORMATION = 203, "Non-Authoritative Information"
+    NO_CONTENT = 204, "No Content"
+    RESET_CONTENT = 205, "Reset Content"
+    PARTIAL_CONTENT = 206, "Partial Content"
+    MULTI_STATUS = 207, "Multi-Status"
+    ALREADY_REPORTED = 208, "Already Reported"
+    IM_USED = 226, "IM Used"
+
+    # redirection
+    MULTIPLE_CHOICES = 300, "Multiple Choices"
+    MOVED_PERMANENTLY = 301, "Moved Permanently"
+    FOUND = 302, "Found"
+    SEE_OTHER = 303, "See Other"
+    NOT_MODIFIED = 304, "Not Modified"
+    USE_PROXY = 305, "Use Proxy"
+    TEMPORARY_REDIRECT = 307, "Temporary Redirect"
+    PERMANENT_REDIRECT = 308, "Permanent Redirect"
+
+    # client error
+    BAD_REQUEST = 400, "Bad Request"
+    UNAUTHORIZED = 401, "Unauthorized"
+    PAYMENT_REQUIRED = 402, "Payment Required"
+    FORBIDDEN = 403, "Forbidden"
+    NOT_FOUND = 404, "Not Found"
+    METHOD_NOT_ALLOWED = 405, "Method Not Allowed"
+    NOT_ACCEPTABLE = 406, "Not Acceptable"
+    PROXY_AUTHENTICATION_REQUIRED = 407, "Proxy Authentication Required"
+    REQUEST_TIMEOUT = 408, "Request Timeout"
+    CONFLICT = 409, "Conflict"
+    GONE = 410, "Gone"
+    LENGTH_REQUIRED = 411, "Length Required"
+    PRECONDITION_FAILED = 412, "Precondition Failed"
+    CONTENT_TOO_LARGE = 413, "Content Too Large"
+    URI_TOO_LONG = 414, "URI Too Long"
+    UNSUPPORTED_MEDIA_TYPE = 415, "Unsupported Media Type"
+    RANGE_NOT_SATISFIABLE = 416, "Range Not Satisfiable"
+    EXPECTATION_FAILED = 417, "Expectation Failed"
+    IM_A_TEAPOT = 418, "I'm a teapot"
+    MISDIRECTED_REQUEST = 421, "Misdirected Request"
+    UNPROCESSABLE_CONTENT = 422, "Unprocessable Content"
+    LOCKED = 423, "Locked"
+    FAILED_DEPENDENCY = 424, "Failed Dependency"
+    TOO_EARLY = 425, "Too Early"
+    UPGRADE_REQUIRED = 426, "Upgrade Required"
+    PRECONDITION_REQUIRED = 428, "Precondition Required"
+    TOO_MANY_REQUESTS = 429, "Too Many Requests"
+    REQUEST_HEADER_FIELDS_TOO_LARGE = 431, "Request Header Fields Too Large"
+    UNAVAILABLE_FOR_LEGAL_REASONS = 451, "Unavailable For Legal Reasons"
+
+    # server errors
+    INTERNAL_SERVER_ERROR = 500, "Internal Server Error"
+    NOT_IMPLEMENTED = 501, "Not Implemented"
+    BAD_GATEWAY = 502, "Bad Gateway"
+    SERVICE_UNAVAILABLE = 503, "Service Unavailable"
+    GATEWAY_TIMEOUT = 504, "Gateway Timeout"
+    HTTP_VERSION_NOT_SUPPORTED = 505, "HTTP Version Not Supported"
+    VARIANT_ALSO_NEGOTIATES = 506, "Variant Also Negotiates"
+    INSUFFICIENT_STORAGE = 507, "Insufficient Storage"
+    LOOP_DETECTED = 508, "Loop Detected"
+    NOT_EXTENDED = 510, "Not Extended"
+    NETWORK_AUTHENTICATION_REQUIRED = 511, "Network Authentication Required"
+
+    # Deprecated aliases for names replaced by RFC 9110.
+    REQUEST_ENTITY_TOO_LARGE = CONTENT_TOO_LARGE
+    REQUEST_URI_TOO_LONG = URI_TOO_LONG
+    REQUESTED_RANGE_NOT_SATISFIABLE = RANGE_NOT_SATISFIABLE
+    UNPROCESSABLE_ENTITY = UNPROCESSABLE_CONTENT
+
+
+# Include lower-case styles for `requests` compatibility.
+for name, code in codes.__members__.items():
+    setattr(codes, name.lower(), int(code))
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb822b71d880b0d1f64d0b941c9f90d67b9b91a1
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__init__.py
@@ -0,0 +1,27 @@
+import sys
+
+from .asgi import ASGITransport
+from .base import AsyncBaseTransport, BaseTransport
+from .mock import MockTransport
+from .wsgi import WSGITransport
+
+if sys.platform == "emscripten":  # pragma: nocover
+    if sys.version_info < (3, 12):
+        raise RuntimeError("httpx2 requires Python 3.12+ on Emscripten.")
+
+    from httpx2_jsfetch import (
+        AsyncJavascriptFetchTransport as AsyncHTTPTransport,
+        JavascriptFetchTransport as HTTPTransport,
+    )
+else:
+    from .default import AsyncHTTPTransport, HTTPTransport
+
+__all__ = [
+    "ASGITransport",
+    "AsyncBaseTransport",
+    "BaseTransport",
+    "AsyncHTTPTransport",
+    "HTTPTransport",
+    "MockTransport",
+    "WSGITransport",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..27421396cccb564d8b4af876f2cb37a022c4044a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/asgi.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/asgi.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..edc84bd3992a023f293e5c2d769333a4599bd12d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/asgi.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/base.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/base.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06c2457a2cecb8caead04990e4ae95a1f212ab97
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/base.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/default.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/default.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..010b082a9c37b5b69041e6a45e148a504ee81e50
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/default.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/mock.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/mock.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..faf0de97584162b5b4729b0243edc5f62d0fde29
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/mock.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/wsgi.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/wsgi.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3222387e1a5330c25ee288c3a0ccc94d4441261d
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/__pycache__/wsgi.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/asgi.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/asgi.py
new file mode 100644
index 0000000000000000000000000000000000000000..33f25db347c62204d0d5568b2df3379c580d501f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/asgi.py
@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+import typing
+
+from .._models import Request, Response
+from .._types import AsyncByteStream
+from .base import AsyncBaseTransport
+
+if typing.TYPE_CHECKING:
+    import asyncio
+
+    import trio
+
+    Event = asyncio.Event | trio.Event
+
+
+_Message = typing.MutableMapping[str, typing.Any]
+_Receive = typing.Callable[[], typing.Awaitable[_Message]]
+_Send = typing.Callable[[typing.MutableMapping[str, typing.Any]], typing.Awaitable[None]]
+_ASGIApp = typing.Callable[[typing.MutableMapping[str, typing.Any], _Receive, _Send], typing.Awaitable[None]]
+
+__all__ = ["ASGITransport"]
+
+
+def is_running_trio() -> bool:
+    try:
+        # sniffio is a dependency of trio.
+
+        # See https://github.com/python-trio/trio/issues/2802
+        import sniffio
+
+        if sniffio.current_async_library() == "trio":
+            return True
+    except ImportError:  # pragma: no cover
+        pass
+
+    return False
+
+
+def create_event() -> Event:
+    if is_running_trio():
+        import trio
+
+        return trio.Event()
+
+    import asyncio
+
+    return asyncio.Event()
+
+
+class ASGIResponseStream(AsyncByteStream):
+    def __init__(self, body: list[bytes]) -> None:
+        self._body = body
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        yield b"".join(self._body)
+
+
+class ASGITransport(AsyncBaseTransport):
+    """
+    A custom AsyncTransport that handles sending requests directly to an ASGI app.
+
+    ```python
+    transport = httpx2.ASGITransport(
+        app=app,
+        root_path="/submount",
+        client=("1.2.3.4", 123)
+    )
+    client = httpx2.AsyncClient(transport=transport)
+    ```
+
+    Arguments:
+        app: The ASGI application.
+        raise_app_exceptions: Boolean indicating if exceptions in the application
+            should be raised. Default to `True`. Can be set to `False` for use cases
+            such as testing the content of a client 500 response.
+        root_path: The root path on which the ASGI application should be mounted.
+        client: A two-tuple indicating the client IP and port of incoming requests.
+    """
+
+    def __init__(
+        self,
+        app: _ASGIApp,
+        raise_app_exceptions: bool = True,
+        root_path: str = "",
+        client: tuple[str, int] = ("127.0.0.1", 123),
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.root_path = root_path
+        self.client = client
+
+    async def handle_async_request(self, request: Request) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        # ASGI scope.
+        scope = {
+            "type": "http",
+            "asgi": {"version": "3.0"},
+            "http_version": "1.1",
+            "method": request.method,
+            "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
+            "scheme": request.url.scheme,
+            "path": request.url.path,
+            "raw_path": request.url.raw_path.split(b"?")[0],
+            "query_string": request.url.query,
+            "server": (request.url.host, request.url.port),
+            "client": self.client,
+            "root_path": self.root_path,
+        }
+
+        # Request.
+        request_body_chunks = request.stream.__aiter__()
+        request_complete = False
+
+        # Response.
+        status_code = None
+        response_headers = None
+        body_parts: list[bytes] = []
+        response_started = False
+        response_complete = create_event()
+
+        # ASGI callables.
+
+        async def receive() -> dict[str, typing.Any]:
+            nonlocal request_complete
+
+            if request_complete:
+                await response_complete.wait()
+                return {"type": "http.disconnect"}
+
+            try:
+                body = await request_body_chunks.__anext__()
+            except StopAsyncIteration:
+                request_complete = True
+                return {"type": "http.request", "body": b"", "more_body": False}
+            return {"type": "http.request", "body": body, "more_body": True}
+
+        async def send(message: typing.MutableMapping[str, typing.Any]) -> None:
+            nonlocal status_code, response_headers, response_started
+
+            if message["type"] == "http.response.start":
+                assert not response_started
+
+                status_code = message["status"]
+                response_headers = message.get("headers", [])
+                response_started = True
+
+            elif message["type"] == "http.response.body":
+                assert not response_complete.is_set()
+                body = message.get("body", b"")
+                more_body = message.get("more_body", False)
+
+                if body and request.method != "HEAD":
+                    body_parts.append(body)
+
+                if not more_body:
+                    response_complete.set()
+
+        try:
+            await self.app(scope, receive, send)
+        except Exception:
+            if self.raise_app_exceptions:
+                raise
+
+            response_complete.set()
+            if status_code is None:
+                status_code = 500
+            if response_headers is None:
+                response_headers = {}
+
+        assert response_complete.is_set()
+        assert status_code is not None
+        assert response_headers is not None
+
+        stream = ASGIResponseStream(body_parts)
+
+        return Response(status_code, headers=response_headers, stream=stream)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/base.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/base.py
new file mode 100644
index 0000000000000000000000000000000000000000..30e909016a8d46633597e26bad88fc732bdfc02f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/base.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import typing
+from types import TracebackType
+
+from .._models import Request, Response
+
+# TODO(Marcelo): When Python 3.10 reaches EOF, we can use `typing.Self` instead of defining those two.
+T = typing.TypeVar("T", bound="BaseTransport")
+A = typing.TypeVar("A", bound="AsyncBaseTransport")
+
+__all__ = ["AsyncBaseTransport", "BaseTransport"]
+
+
+class BaseTransport:
+    def __enter__(self: T) -> T:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self.close()
+
+    def handle_request(self, request: Request) -> Response:
+        """
+        Send a single HTTP request and return a response.
+
+        Developers shouldn't typically ever need to call into this API directly,
+        since the Client class provides all the higher level user-facing API
+        niceties.
+
+        In order to properly release any network resources, the response
+        stream should *either* be consumed immediately, with a call to
+        `response.stream.read()`, or else the `handle_request` call should
+        be followed with a try/finally block to ensuring the stream is
+        always closed.
+
+        Example usage:
+
+            with httpx2.HTTPTransport() as transport:
+                req = httpx2.Request(
+                    method=b"GET",
+                    url=(b"https", b"www.example.com", 443, b"/"),
+                    headers=[(b"Host", b"www.example.com")],
+                )
+                resp = transport.handle_request(req)
+                body = resp.stream.read()
+                print(resp.status_code, resp.headers, body)
+
+
+        Takes a `Request` instance as the only argument.
+
+        Returns a `Response` instance.
+        """
+        raise NotImplementedError("The 'handle_request' method must be implemented.")  # pragma: no cover
+
+    def close(self) -> None:
+        pass
+
+
+class AsyncBaseTransport:
+    async def __aenter__(self: A) -> A:
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        await self.aclose()
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        raise NotImplementedError("The 'handle_async_request' method must be implemented.")  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/default.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/default.py
new file mode 100644
index 0000000000000000000000000000000000000000..17d48c4f93d5546b39d82d12739876b619e1035d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/default.py
@@ -0,0 +1,400 @@
+"""
+Custom transports, with nicely configured defaults.
+
+The following additional keyword arguments are currently supported by httpcore...
+
+* uds: str
+* local_address: str
+* retries: int
+
+Example usages...
+
+# Disable HTTP/2 on a single specific domain.
+mounts = {
+    "all://": httpx2.HTTPTransport(http2=True),
+    "all://*example.org": httpx2.HTTPTransport()
+}
+
+# Using advanced httpcore configuration, with connection retries.
+transport = httpx2.HTTPTransport(retries=1)
+client = httpx2.Client(transport=transport)
+
+# Using advanced httpcore configuration, with unix domain sockets.
+transport = httpx2.HTTPTransport(uds="socket.uds")
+client = httpx2.Client(transport=transport)
+"""
+
+from __future__ import annotations
+
+import contextlib
+import typing
+from collections.abc import Generator
+from types import TracebackType
+
+if typing.TYPE_CHECKING:  # pragma: no cover
+    import ssl
+
+    import httpx2
+
+from .._config import DEFAULT_LIMITS, Limits, Proxy, create_ssl_context
+from .._exceptions import (
+    ConnectError,
+    ConnectTimeout,
+    LocalProtocolError,
+    NetworkError,
+    PoolTimeout,
+    ProtocolError,
+    ProxyError,
+    ReadError,
+    ReadTimeout,
+    RemoteProtocolError,
+    TimeoutException,
+    UnsupportedProtocol,
+    WriteError,
+    WriteTimeout,
+)
+from .._models import Request, Response
+from .._types import AsyncByteStream, CertTypes, ProxyTypes, SyncByteStream
+from .._urls import URL
+from .base import AsyncBaseTransport, BaseTransport
+
+T = typing.TypeVar("T", bound="HTTPTransport")
+A = typing.TypeVar("A", bound="AsyncHTTPTransport")
+
+SOCKET_OPTION = tuple[int, int, int] | tuple[int, int, bytes | bytearray] | tuple[int, int, None, int]
+
+__all__ = ["AsyncHTTPTransport", "HTTPTransport"]
+
+HTTPCORE_EXC_MAP: dict[type[Exception], type[httpx2.HTTPError]] = {}
+
+
+def _load_httpcore_exceptions() -> dict[type[Exception], type[httpx2.HTTPError]]:
+    import httpcore2
+
+    return {
+        httpcore2.TimeoutException: TimeoutException,
+        httpcore2.ConnectTimeout: ConnectTimeout,
+        httpcore2.ReadTimeout: ReadTimeout,
+        httpcore2.WriteTimeout: WriteTimeout,
+        httpcore2.PoolTimeout: PoolTimeout,
+        httpcore2.NetworkError: NetworkError,
+        httpcore2.ConnectError: ConnectError,
+        httpcore2.ReadError: ReadError,
+        httpcore2.WriteError: WriteError,
+        httpcore2.ProxyError: ProxyError,
+        httpcore2.UnsupportedProtocol: UnsupportedProtocol,
+        httpcore2.ProtocolError: ProtocolError,
+        httpcore2.LocalProtocolError: LocalProtocolError,
+        httpcore2.RemoteProtocolError: RemoteProtocolError,
+    }
+
+
+@contextlib.contextmanager
+def map_httpcore_exceptions() -> Generator[None]:
+    global HTTPCORE_EXC_MAP
+    if len(HTTPCORE_EXC_MAP) == 0:
+        HTTPCORE_EXC_MAP = _load_httpcore_exceptions()
+    try:
+        yield
+    except Exception as exc:
+        mapped_exc = None
+
+        for from_exc, to_exc in HTTPCORE_EXC_MAP.items():
+            if not isinstance(exc, from_exc):
+                continue
+            # We want to map to the most specific exception we can find.
+            # Eg if `exc` is an `httpcore2.ReadTimeout`, we want to map to
+            # `httpx2.ReadTimeout`, not just `httpx2.TimeoutException`.
+            if mapped_exc is None or issubclass(to_exc, mapped_exc):
+                mapped_exc = to_exc
+
+        if mapped_exc is None:  # pragma: no cover
+            raise
+
+        message = str(exc)
+        raise mapped_exc(message) from exc
+
+
+class ResponseStream(SyncByteStream):
+    def __init__(self, httpcore_stream: typing.Iterable[bytes]) -> None:
+        self._httpcore_stream = httpcore_stream
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        with map_httpcore_exceptions():
+            yield from self._httpcore_stream
+
+    def close(self) -> None:
+        if hasattr(self._httpcore_stream, "close"):
+            self._httpcore_stream.close()
+
+
+class HTTPTransport(BaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        import httpcore2
+
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore2.ConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore2.HTTPProxy(
+                proxy_url=httpcore2.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                ssl_context=ssl_context,
+                proxy_ssl_context=proxy.ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("socks5", "socks5h"):
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore2.SOCKSProxy(
+                proxy_url=httpcore2.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                f"Proxy protocol must be either 'http', 'https', 'socks5', or 'socks5h', but got {proxy.url.scheme!r}."
+            )
+
+    def __enter__(self: T) -> T:  # Use generics for subclass support.
+        self._pool.__enter__()
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            self._pool.__exit__(exc_type, exc_value, traceback)
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, SyncByteStream)
+        import httpcore2
+
+        req = httpcore2.Request(
+            method=request.method,
+            url=httpcore2.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = self._pool.handle_request(req)
+
+        assert isinstance(resp.stream, typing.Iterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=ResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    def close(self) -> None:
+        self._pool.close()
+
+
+class AsyncResponseStream(AsyncByteStream):
+    def __init__(self, httpcore_stream: typing.AsyncIterable[bytes]) -> None:
+        self._httpcore_stream = httpcore_stream
+
+    async def __aiter__(self) -> typing.AsyncIterator[bytes]:
+        with map_httpcore_exceptions():
+            async for part in self._httpcore_stream:
+                yield part
+
+    async def aclose(self) -> None:
+        if hasattr(self._httpcore_stream, "aclose"):
+            await self._httpcore_stream.aclose()
+
+
+class AsyncHTTPTransport(AsyncBaseTransport):
+    def __init__(
+        self,
+        verify: ssl.SSLContext | str | bool = True,
+        cert: CertTypes | None = None,
+        trust_env: bool = True,
+        http1: bool = True,
+        http2: bool = False,
+        limits: Limits = DEFAULT_LIMITS,
+        proxy: ProxyTypes | None = None,
+        uds: str | None = None,
+        local_address: str | None = None,
+        retries: int = 0,
+        socket_options: typing.Iterable[SOCKET_OPTION] | None = None,
+    ) -> None:
+        import httpcore2
+
+        proxy = Proxy(url=proxy) if isinstance(proxy, (str, URL)) else proxy
+        ssl_context = create_ssl_context(verify=verify, cert=cert, trust_env=trust_env)
+
+        if proxy is None:
+            self._pool = httpcore2.AsyncConnectionPool(
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                uds=uds,
+                local_address=local_address,
+                retries=retries,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("http", "https"):
+            self._pool = httpcore2.AsyncHTTPProxy(
+                proxy_url=httpcore2.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                proxy_headers=proxy.headers.raw,
+                proxy_ssl_context=proxy.ssl_context,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+                socket_options=socket_options,
+            )
+        elif proxy.url.scheme in ("socks5", "socks5h"):
+            try:
+                import socksio  # noqa
+            except ImportError:  # pragma: no cover
+                raise ImportError(
+                    "Using SOCKS proxy, but the 'socksio' package is not installed. "
+                    "Make sure to install httpx using `pip install httpx[socks]`."
+                ) from None
+
+            self._pool = httpcore2.AsyncSOCKSProxy(
+                proxy_url=httpcore2.URL(
+                    scheme=proxy.url.raw_scheme,
+                    host=proxy.url.raw_host,
+                    port=proxy.url.port,
+                    target=proxy.url.raw_path,
+                ),
+                proxy_auth=proxy.raw_auth,
+                ssl_context=ssl_context,
+                max_connections=limits.max_connections,
+                max_keepalive_connections=limits.max_keepalive_connections,
+                keepalive_expiry=limits.keepalive_expiry,
+                http1=http1,
+                http2=http2,
+            )
+        else:  # pragma: no cover
+            raise ValueError(
+                f"Proxy protocol must be either 'http', 'https', 'socks5', or 'socks5h', but got {proxy.url.scheme!r}."
+            )
+
+    async def __aenter__(self: A) -> A:  # Use generics for subclass support.
+        await self._pool.__aenter__()
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        with map_httpcore_exceptions():
+            await self._pool.__aexit__(exc_type, exc_value, traceback)
+
+    async def handle_async_request(
+        self,
+        request: Request,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+        import httpcore2
+
+        req = httpcore2.Request(
+            method=request.method,
+            url=httpcore2.URL(
+                scheme=request.url.raw_scheme,
+                host=request.url.raw_host,
+                port=request.url.port,
+                target=request.url.raw_path,
+            ),
+            headers=request.headers.raw,
+            content=request.stream,
+            extensions=request.extensions,
+        )
+        with map_httpcore_exceptions():
+            resp = await self._pool.handle_async_request(req)
+
+        assert isinstance(resp.stream, typing.AsyncIterable)
+
+        return Response(
+            status_code=resp.status,
+            headers=resp.headers,
+            stream=AsyncResponseStream(resp.stream),
+            extensions=resp.extensions,
+        )
+
+    async def aclose(self) -> None:
+        await self._pool.aclose()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/mock.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/mock.py
new file mode 100644
index 0000000000000000000000000000000000000000..7db82d1042b1dc91ada84af68114170bbbd5895c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/mock.py
@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import typing
+
+from .._models import Request, Response
+from .base import AsyncBaseTransport, BaseTransport
+
+SyncHandler = typing.Callable[[Request], Response]
+AsyncHandler = typing.Callable[[Request], typing.Coroutine[None, None, Response]]
+
+
+__all__ = ["MockTransport"]
+
+
+class MockTransport(AsyncBaseTransport, BaseTransport):
+    def __init__(self, handler: SyncHandler | AsyncHandler) -> None:
+        self.handler = handler
+
+    def handle_request(
+        self,
+        request: Request,
+    ) -> Response:
+        request.read()
+        response = self.handler(request)
+        if not isinstance(response, Response):  # pragma: no cover
+            raise TypeError("Cannot use an async handler in a sync Client")
+        return response
+
+    async def handle_async_request(self, request: Request) -> Response:
+        await request.aread()
+        response = self.handler(request)
+
+        # Allow handler to *optionally* be an `async` function.
+        # If it is, then the `response` variable need to be awaited to actually
+        # return the result.
+
+        if not isinstance(response, Response):
+            response = await response
+
+        return response
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/wsgi.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/wsgi.py
new file mode 100644
index 0000000000000000000000000000000000000000..f15ec38b34d5ce84bb7739e58e3e7ee1794d05ed
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_transports/wsgi.py
@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+import io
+import itertools
+import sys
+import typing
+
+from .._models import Request, Response
+from .._types import SyncByteStream
+from .base import BaseTransport
+
+if typing.TYPE_CHECKING:
+    from _typeshed import OptExcInfo  # pragma: no cover
+    from _typeshed.wsgi import WSGIApplication  # pragma: no cover
+
+_T = typing.TypeVar("_T")
+
+
+__all__ = ["WSGITransport"]
+
+
+def _skip_leading_empty_chunks(body: typing.Iterable[_T]) -> typing.Iterable[_T]:
+    body = iter(body)
+    for chunk in body:
+        if chunk:
+            return itertools.chain([chunk], body)
+    return []
+
+
+class WSGIByteStream(SyncByteStream):
+    def __init__(self, result: typing.Iterable[bytes]) -> None:
+        self._close = getattr(result, "close", None)
+        self._result = _skip_leading_empty_chunks(result)
+
+    def __iter__(self) -> typing.Iterator[bytes]:
+        yield from self._result
+
+    def close(self) -> None:
+        if self._close is not None:
+            self._close()
+
+
+class WSGITransport(BaseTransport):
+    """
+    A custom transport that handles sending requests directly to an WSGI app.
+    The simplest way to use this functionality is to use the `app` argument.
+
+    ```
+    client = httpx2.Client(app=app)
+    ```
+
+    Alternatively, you can setup the transport instance explicitly.
+    This allows you to include any additional configuration arguments specific
+    to the WSGITransport class:
+
+    ```
+    transport = httpx2.WSGITransport(
+        app=app,
+        script_name="/submount",
+        remote_addr="1.2.3.4"
+    )
+    client = httpx2.Client(transport=transport)
+    ```
+
+    Arguments:
+        app: The WSGI application.
+        raise_app_exceptions: Boolean indicating if exceptions in the application
+            should be raised. Default to `True`. Can be set to `False` for use cases
+            such as testing the content of a client 500 response.
+        script_name: The root path on which the WSGI application should be mounted.
+        remote_addr: A string indicating the client IP of incoming requests.
+    """
+
+    def __init__(
+        self,
+        app: WSGIApplication,
+        raise_app_exceptions: bool = True,
+        script_name: str = "",
+        remote_addr: str = "127.0.0.1",
+        wsgi_errors: typing.TextIO | None = None,
+    ) -> None:
+        self.app = app
+        self.raise_app_exceptions = raise_app_exceptions
+        self.script_name = script_name
+        self.remote_addr = remote_addr
+        self.wsgi_errors = wsgi_errors
+
+    def handle_request(self, request: Request) -> Response:
+        request.read()
+        wsgi_input = io.BytesIO(request.content)
+
+        port = request.url.port or {"http": 80, "https": 443}[request.url.scheme]
+        environ = {
+            "wsgi.version": (1, 0),
+            "wsgi.url_scheme": request.url.scheme,
+            "wsgi.input": wsgi_input,
+            "wsgi.errors": self.wsgi_errors or sys.stderr,
+            "wsgi.multithread": True,
+            "wsgi.multiprocess": False,
+            "wsgi.run_once": False,
+            "REQUEST_METHOD": request.method,
+            "SCRIPT_NAME": self.script_name,
+            "PATH_INFO": request.url.path,
+            "QUERY_STRING": request.url.query.decode("ascii"),
+            "SERVER_NAME": request.url.host,
+            "SERVER_PORT": str(port),
+            "SERVER_PROTOCOL": "HTTP/1.1",
+            "REMOTE_ADDR": self.remote_addr,
+        }
+        if request.content and "Content-Length" not in request.headers:
+            environ["CONTENT_LENGTH"] = str(len(request.content))
+        for header_key, header_value in request.headers.raw:
+            key = header_key.decode("ascii").upper().replace("-", "_")
+            if key not in ("CONTENT_TYPE", "CONTENT_LENGTH"):
+                key = "HTTP_" + key
+            environ[key] = header_value.decode("ascii")
+
+        seen_status = None
+        seen_response_headers = None
+        seen_exc_info = None
+
+        def start_response(
+            status: str,
+            response_headers: list[tuple[str, str]],
+            exc_info: OptExcInfo | None = None,
+        ) -> typing.Callable[[bytes], typing.Any]:
+            nonlocal seen_status, seen_response_headers, seen_exc_info
+            seen_status = status
+            seen_response_headers = response_headers
+            seen_exc_info = exc_info
+            return lambda _: None
+
+        result = self.app(environ, start_response)
+
+        stream = WSGIByteStream(result)
+
+        assert seen_status is not None
+        assert seen_response_headers is not None
+        if seen_exc_info and seen_exc_info[0] and self.raise_app_exceptions:
+            raise seen_exc_info[1]
+
+        status_code = int(seen_status.split()[0])
+        headers = [(key.encode("ascii"), value.encode("ascii")) for key, value in seen_response_headers]
+
+        return Response(status_code, headers=headers, stream=stream)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_types.py
new file mode 100644
index 0000000000000000000000000000000000000000..3635da6bcf4d796829f45c64b7af24f1eecd60e8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_types.py
@@ -0,0 +1,86 @@
+"""
+Type definitions for type checking purposes.
+"""
+
+from collections.abc import AsyncIterable, AsyncIterator, Callable, Iterable, Iterator, Mapping, Sequence
+from http.cookiejar import CookieJar
+from typing import IO, TYPE_CHECKING, Any, Union
+
+if TYPE_CHECKING:
+    from ._auth import Auth  # noqa: F401
+    from ._config import Proxy, Timeout  # noqa: F401
+    from ._models import Cookies, Headers, Request  # noqa: F401
+    from ._urls import URL, QueryParams  # noqa: F401
+
+
+PrimitiveData = str | int | float | bool | None
+
+URLTypes = Union["URL", str]
+
+QueryParamTypes = Union[
+    "QueryParams",
+    Mapping[str, PrimitiveData | Sequence[PrimitiveData]],
+    list[tuple[str, PrimitiveData]],
+    tuple[tuple[str, PrimitiveData], ...],
+    str,
+    bytes,
+]
+
+HeaderTypes = Union[
+    "Headers",
+    Mapping[str, str],
+    Mapping[bytes, bytes],
+    Sequence[tuple[str, str]],
+    Sequence[tuple[bytes, bytes]],
+]
+
+CookieTypes = Union["Cookies", CookieJar, dict[str, str], list[tuple[str, str]]]
+
+TimeoutTypes = Union[float | None, tuple[float | None, float | None, float | None, float | None], "Timeout"]
+ProxyTypes = Union["URL", str, "Proxy"]
+CertTypes = str | tuple[str, str] | tuple[str, str, str]
+
+AuthTypes = Union[tuple[str | bytes, str | bytes], Callable[["Request"], "Request"], "Auth"]
+
+RequestContent = str | bytes | Iterable[bytes] | AsyncIterable[bytes]
+ResponseContent = str | bytes | Iterable[bytes] | AsyncIterable[bytes]
+ResponseExtensions = Mapping[str, Any]
+
+RequestData = Mapping[str, Any]
+
+FileContent = IO[bytes] | bytes | str
+FileTypes = (
+    # # file (or bytes)
+    FileContent
+    # # (filename, file (or bytes))
+    | tuple[str | None, FileContent]
+    # # (filename, file (or bytes), content_type)
+    | tuple[str | None, FileContent, str | None]
+    | tuple[str | None, FileContent, str | None, Mapping[str, str]]
+)
+RequestFiles = Mapping[str, FileTypes] | Sequence[tuple[str, FileTypes]]
+
+RequestExtensions = Mapping[str, Any]
+
+__all__ = ["AsyncByteStream", "SyncByteStream"]
+
+
+class SyncByteStream:
+    def __iter__(self) -> Iterator[bytes]:
+        raise NotImplementedError("The '__iter__' method must be implemented.")  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    def close(self) -> None:
+        """
+        Subclasses can override this method to release any network resources
+        after a request/response cycle is complete.
+        """
+
+
+class AsyncByteStream:
+    async def __aiter__(self) -> AsyncIterator[bytes]:
+        raise NotImplementedError("The '__aiter__' method must be implemented.")  # pragma: no cover
+        yield b""  # pragma: no cover
+
+    async def aclose(self) -> None:
+        pass
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urlparse.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urlparse.py
new file mode 100644
index 0000000000000000000000000000000000000000..4a9d9bcffd9136ae6fc70000eeb4573ea2e32488
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urlparse.py
@@ -0,0 +1,502 @@
+"""
+An implementation of `urlparse` that provides URL validation and normalization
+as described by RFC3986.
+
+We rely on this implementation rather than the one in Python's stdlib, because:
+
+* It provides more complete URL validation.
+* It properly differentiates between an empty querystring and an absent querystring,
+  to distinguish URLs with a trailing '?'.
+* It handles scheme, hostname, port, and path normalization.
+* It supports IDNA hostnames, normalizing them to their encoded form.
+* The API supports passing individual components, as well as the complete URL string.
+
+Previously we relied on the excellent `rfc3986` package to handle URL parsing and
+validation, but this module provides a simpler alternative, with less indirection
+required.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import re
+import typing
+
+import idna
+
+from ._exceptions import InvalidURL
+
+MAX_URL_LENGTH = 65536
+
+# https://datatracker.ietf.org/doc/html/rfc3986.html#section-2.3
+UNRESERVED_CHARACTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~"
+SUB_DELIMS = "!$&'()*+,;="
+
+PERCENT_ENCODED_REGEX = re.compile("%[A-Fa-f0-9]{2}")
+
+# https://url.spec.whatwg.org/#percent-encoded-bytes
+
+# The fragment percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+003C (<), U+003E (>), and U+0060 (`).
+FRAG_SAFE = "".join([chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x3C, 0x3E, 0x60)])
+
+# The query percent-encode set is the C0 control percent-encode set
+# and U+0020 SPACE, U+0022 ("), U+0023 (#), U+003C (<), and U+003E (>).
+QUERY_SAFE = "".join([chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E)])
+
+# The path percent-encode set is the query percent-encode set
+# and U+003F (?), U+0060 (`), U+007B ({), and U+007D (}).
+PATH_SAFE = "".join(
+    [chr(i) for i in range(0x20, 0x7F) if i not in (0x20, 0x22, 0x23, 0x3C, 0x3E) + (0x3F, 0x60, 0x7B, 0x7D)]
+)
+
+# The userinfo percent-encode set is the path percent-encode set
+# and U+002F (/), U+003A (:), U+003B (;), U+003D (=), U+0040 (@),
+# U+005B ([) to U+005E (^), inclusive, and U+007C (|).
+USERNAME_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+PASSWORD_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3A, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+# Note... The terminology 'userinfo' percent-encode set in the WHATWG document
+# is used for the username and password quoting. For the joint userinfo component
+# we remove U+003A (:) from the safe set.
+USERINFO_SAFE = "".join(
+    [
+        chr(i)
+        for i in range(0x20, 0x7F)
+        if i
+        not in (0x20, 0x22, 0x23, 0x3C, 0x3E)
+        + (0x3F, 0x60, 0x7B, 0x7D)
+        + (0x2F, 0x3B, 0x3D, 0x40, 0x5B, 0x5C, 0x5D, 0x5E, 0x7C)
+    ]
+)
+
+
+# {scheme}:      (optional)
+# //{authority}  (optional)
+# {path}
+# ?{query}       (optional)
+# #{fragment}    (optional)
+URL_REGEX = re.compile(
+    (
+        r"(?:(?P<scheme>{scheme}):)?"
+        r"(?://(?P<authority>{authority}))?"
+        r"(?P<path>{path})"
+        r"(?:\?(?P<query>{query}))?"
+        r"(?:#(?P<fragment>{fragment}))?"
+    ).format(
+        scheme="([a-zA-Z][a-zA-Z0-9+.-]*)?",
+        authority="[^/?#]*",
+        path="[^?#]*",
+        query="[^#]*",
+        fragment=".*",
+    )
+)
+
+# {userinfo}@    (optional)
+# {host}
+# :{port}        (optional)
+AUTHORITY_REGEX = re.compile(
+    (r"(?:(?P<userinfo>{userinfo})@)?" r"(?P<host>{host})" r":?(?P<port>{port})?").format(
+        userinfo=".*",  # Any character sequence.
+        host="(\\[.*\\]|[^:@]*)",  # Either any character sequence excluding ':' or '@',
+        # or an IPv6 address enclosed within square brackets.
+        port=".*",  # Any character sequence.
+    )
+)
+
+
+# If we call urlparse with an individual component, then we need to regex
+# validate that component individually.
+# Note that we're duplicating the same strings as above. Shock! Horror!!
+COMPONENT_REGEX = {
+    "scheme": re.compile("([a-zA-Z][a-zA-Z0-9+.-]*)?"),
+    "authority": re.compile("[^/?#]*"),
+    "path": re.compile("[^?#]*"),
+    "query": re.compile("[^#]*"),
+    "fragment": re.compile(".*"),
+    "userinfo": re.compile("[^@]*"),
+    "host": re.compile("(\\[.*\\]|[^:]*)"),
+    "port": re.compile(".*"),
+}
+
+
+# We use these simple regexs as a first pass before handing off to
+# the stdlib 'ipaddress' module for IP address validation.
+IPv4_STYLE_HOSTNAME = re.compile(r"^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$")
+IPv6_STYLE_HOSTNAME = re.compile(r"^\[.*\]$")
+
+
+class ParseResult(typing.NamedTuple):
+    scheme: str
+    userinfo: str
+    host: str
+    port: int | None
+    path: str
+    query: str | None
+    fragment: str | None
+
+    @property
+    def authority(self) -> str:
+        return "".join(
+            [
+                f"{self.userinfo}@" if self.userinfo else "",
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    @property
+    def netloc(self) -> str:
+        return "".join(
+            [
+                f"[{self.host}]" if ":" in self.host else self.host,
+                f":{self.port}" if self.port is not None else "",
+            ]
+        )
+
+    def copy_with(self, **kwargs: str | None) -> ParseResult:
+        if not kwargs:
+            return self
+
+        defaults = {
+            "scheme": self.scheme,
+            "authority": self.authority,
+            "path": self.path,
+            "query": self.query,
+            "fragment": self.fragment,
+        }
+        defaults.update(kwargs)
+        return urlparse("", **defaults)
+
+    def __str__(self) -> str:
+        authority = self.authority
+        return "".join(
+            [
+                f"{self.scheme}:" if self.scheme else "",
+                f"//{authority}" if authority else "",
+                self.path,
+                f"?{self.query}" if self.query is not None else "",
+                f"#{self.fragment}" if self.fragment is not None else "",
+            ]
+        )
+
+
+def urlparse(url: str = "", **kwargs: str | None) -> ParseResult:
+    # Initial basic checks on allowable URLs.
+    # ---------------------------------------
+
+    # Hard limit the maximum allowable URL length.
+    if len(url) > MAX_URL_LENGTH:
+        raise InvalidURL("URL too long")
+
+    # If a URL includes any ASCII control characters including \t, \r, \n,
+    # then treat it as invalid.
+    if any(char.isascii() and not char.isprintable() for char in url):
+        char = next(char for char in url if char.isascii() and not char.isprintable())
+        idx = url.find(char)
+        error = f"Invalid non-printable ASCII character in URL, {char!r} at position {idx}."
+        raise InvalidURL(error)
+
+    # Some keyword arguments require special handling.
+    # ------------------------------------------------
+
+    # Coerce "port" to a string, if it is provided as an integer.
+    if "port" in kwargs:
+        port = kwargs["port"]
+        kwargs["port"] = str(port) if isinstance(port, int) else port
+
+    # Replace "netloc" with "host and "port".
+    if "netloc" in kwargs:
+        netloc = kwargs.pop("netloc") or ""
+        kwargs["host"], _, kwargs["port"] = netloc.partition(":")
+
+    # Replace "username" and/or "password" with "userinfo".
+    if "username" in kwargs or "password" in kwargs:
+        username = quote(kwargs.pop("username", "") or "", safe=USERNAME_SAFE)
+        password = quote(kwargs.pop("password", "") or "", safe=PASSWORD_SAFE)
+        kwargs["userinfo"] = f"{username}:{password}" if password else username
+
+    # Replace "raw_path" with "path" and "query".
+    if "raw_path" in kwargs:
+        raw_path = kwargs.pop("raw_path") or ""
+        kwargs["path"], separator, kwargs["query"] = raw_path.partition("?")
+        if not separator:
+            kwargs["query"] = None
+
+    # Ensure that IPv6 "host" addresses are always escaped with "[...]".
+    if "host" in kwargs:
+        host = kwargs.get("host") or ""
+        if ":" in host and not (host.startswith("[") and host.endswith("]")):
+            kwargs["host"] = f"[{host}]"
+
+    # If any keyword arguments are provided, ensure they are valid.
+    # -------------------------------------------------------------
+
+    for key, value in kwargs.items():
+        if value is not None:
+            if len(value) > MAX_URL_LENGTH:
+                raise InvalidURL(f"URL component '{key}' too long")
+
+            # If a component includes any ASCII control characters including \t, \r, \n,
+            # then treat it as invalid.
+            if any(char.isascii() and not char.isprintable() for char in value):
+                char = next(char for char in value if char.isascii() and not char.isprintable())
+                idx = value.find(char)
+                error = f"Invalid non-printable ASCII character in URL {key} component, {char!r} at position {idx}."
+                raise InvalidURL(error)
+
+            # Ensure that keyword arguments match as a valid regex.
+            if not COMPONENT_REGEX[key].fullmatch(value):
+                raise InvalidURL(f"Invalid URL component '{key}'")
+
+    # The URL_REGEX will always match, but may have empty components.
+    url_match = URL_REGEX.match(url)
+    assert url_match is not None
+    url_dict = url_match.groupdict()
+
+    # * 'scheme', 'authority', and 'path' may be empty strings.
+    # * 'query' may be 'None', indicating no trailing "?" portion.
+    #   Any string including the empty string, indicates a trailing "?".
+    # * 'fragment' may be 'None', indicating no trailing "#" portion.
+    #   Any string including the empty string, indicates a trailing "#".
+    scheme = kwargs.get("scheme", url_dict["scheme"]) or ""
+    authority = kwargs.get("authority", url_dict["authority"]) or ""
+    path = kwargs.get("path", url_dict["path"]) or ""
+    query = kwargs.get("query", url_dict["query"])
+    frag = kwargs.get("fragment", url_dict["fragment"])
+
+    # The AUTHORITY_REGEX will always match, but may have empty components.
+    authority_match = AUTHORITY_REGEX.match(authority)
+    assert authority_match is not None
+    authority_dict = authority_match.groupdict()
+
+    # * 'userinfo' and 'host' may be empty strings.
+    # * 'port' may be 'None'.
+    userinfo = kwargs.get("userinfo", authority_dict["userinfo"]) or ""
+    host = kwargs.get("host", authority_dict["host"]) or ""
+    port = kwargs.get("port", authority_dict["port"])
+
+    # Normalize and validate each component.
+    # We end up with a parsed representation of the URL,
+    # with components that are plain ASCII bytestrings.
+    parsed_scheme: str = scheme.lower()
+    parsed_userinfo: str = quote(userinfo, safe=USERINFO_SAFE)
+    parsed_host: str = encode_host(host)
+    parsed_port: int | None = normalize_port(port, scheme)
+
+    has_scheme = parsed_scheme != ""
+    has_authority = parsed_userinfo != "" or parsed_host != "" or parsed_port is not None
+    validate_path(path, has_scheme=has_scheme, has_authority=has_authority)
+    if has_scheme or has_authority:
+        path = normalize_path(path)
+
+    parsed_path: str = quote(path, safe=PATH_SAFE)
+    parsed_query: str | None = None if query is None else quote(query, safe=QUERY_SAFE)
+    parsed_frag: str | None = None if frag is None else quote(frag, safe=FRAG_SAFE)
+
+    # The parsed ASCII bytestrings are our canonical form.
+    # All properties of the URL are derived from these.
+    return ParseResult(
+        parsed_scheme,
+        parsed_userinfo,
+        parsed_host,
+        parsed_port,
+        parsed_path,
+        parsed_query,
+        parsed_frag,
+    )
+
+
+def encode_host(host: str) -> str:
+    if not host:
+        return ""
+
+    elif IPv4_STYLE_HOSTNAME.match(host):
+        # Validate IPv4 hostnames like #.#.#.#
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # IPv4address = dec-octet "." dec-octet "." dec-octet "." dec-octet
+        try:
+            ipaddress.IPv4Address(host)
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv4 address: {host!r}")
+        return host
+
+    elif IPv6_STYLE_HOSTNAME.match(host):
+        # Validate IPv6 hostnames like [...]
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # "A host identified by an Internet Protocol literal address, version 6
+        # [RFC3513] or later, is distinguished by enclosing the IP literal
+        # within square brackets ("[" and "]").  This is the only place where
+        # square bracket characters are allowed in the URI syntax."
+        try:
+            ipaddress.IPv6Address(host[1:-1])
+        except ipaddress.AddressValueError:
+            raise InvalidURL(f"Invalid IPv6 address: {host!r}")
+        return host[1:-1]
+
+    elif host.isascii():
+        # Regular ASCII hostnames
+        #
+        # From https://datatracker.ietf.org/doc/html/rfc3986/#section-3.2.2
+        #
+        # reg-name    = *( unreserved / pct-encoded / sub-delims )
+        WHATWG_SAFE = '"`{}%|\\'
+        return quote(host.lower(), safe=SUB_DELIMS + WHATWG_SAFE)
+
+    # IDNA hostnames
+    try:
+        return idna.encode(host.lower()).decode("ascii")
+    except idna.IDNAError:
+        raise InvalidURL(f"Invalid IDNA hostname: {host!r}")
+
+
+def normalize_port(port: str | int | None, scheme: str) -> int | None:
+    # From https://tools.ietf.org/html/rfc3986#section-3.2.3
+    #
+    # "A scheme may define a default port.  For example, the "http" scheme
+    # defines a default port of "80", corresponding to its reserved TCP
+    # port number.  The type of port designated by the port number (e.g.,
+    # TCP, UDP, SCTP) is defined by the URI scheme.  URI producers and
+    # normalizers should omit the port component and its ":" delimiter if
+    # port is empty or if its value would be the same as that of the
+    # scheme's default."
+    if port is None or port == "":
+        return None
+
+    try:
+        port_as_int = int(port)
+    except ValueError:
+        raise InvalidURL(f"Invalid port: {port!r}")
+
+    # See https://url.spec.whatwg.org/#url-miscellaneous
+    default_port = {"ftp": 21, "http": 80, "https": 443, "ws": 80, "wss": 443}.get(scheme)
+    if port_as_int == default_port:
+        return None
+    return port_as_int
+
+
+def validate_path(path: str, has_scheme: bool, has_authority: bool) -> None:
+    """
+    Path validation rules that depend on if the URL contains
+    a scheme or authority component.
+
+    See https://datatracker.ietf.org/doc/html/rfc3986.html#section-3.3
+    """
+    if has_authority:
+        # If a URI contains an authority component, then the path component
+        # must either be empty or begin with a slash ("/") character."
+        if path and not path.startswith("/"):
+            raise InvalidURL("For absolute URLs, path must be empty or begin with '/'")
+
+    if not has_scheme and not has_authority:
+        # If a URI does not contain an authority component, then the path cannot begin
+        # with two slash characters ("//").
+        if path.startswith("//"):
+            raise InvalidURL("Relative URLs cannot have a path starting with '//'")
+
+        # In addition, a URI reference (Section 4.1) may be a relative-path reference,
+        # in which case the first path segment cannot contain a colon (":") character.
+        if path.startswith(":"):
+            raise InvalidURL("Relative URLs cannot have a path starting with ':'")
+
+
+def normalize_path(path: str) -> str:
+    """
+    Drop "." and ".." segments from a URL path.
+
+    For example:
+
+        normalize_path("/path/./to/somewhere/..") == "/path/to"
+    """
+    # Fast return when no '.' characters in the path.
+    if "." not in path:
+        return path
+
+    components = path.split("/")
+
+    # Fast return when no '.' or '..' components in the path.
+    if "." not in components and ".." not in components:
+        return path
+
+    # https://datatracker.ietf.org/doc/html/rfc3986#section-5.2.4
+    output: list[str] = []
+    for component in components:
+        if component == ".":
+            pass
+        elif component == "..":
+            if output and output != [""]:
+                output.pop()
+        else:
+            output.append(component)
+    return "/".join(output)
+
+
+def PERCENT(string: str) -> str:
+    return "".join([f"%{byte:02X}" for byte in string.encode("utf-8")])
+
+
+def percent_encoded(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string.
+    """
+    NON_ESCAPED_CHARS = UNRESERVED_CHARACTERS + safe
+
+    # Fast path for strings that don't need escaping.
+    if not string.rstrip(NON_ESCAPED_CHARS):
+        return string
+
+    return "".join([char if char in NON_ESCAPED_CHARS else PERCENT(char) for char in string])
+
+
+def quote(string: str, safe: str) -> str:
+    """
+    Use percent-encoding to quote a string, omitting existing '%xx' escape sequences.
+
+    See: https://www.rfc-editor.org/rfc/rfc3986#section-2.1
+
+    * `string`: The string to be percent-escaped.
+    * `safe`: A string containing characters that may be treated as safe, and do not
+        need to be escaped. Unreserved characters are always treated as safe.
+        See: https://www.rfc-editor.org/rfc/rfc3986#section-2.3
+    """
+    parts: list[str] = []
+    current_position = 0
+    for match in re.finditer(PERCENT_ENCODED_REGEX, string):
+        start_position, end_position = match.start(), match.end()
+        matched_text = match.group(0)
+        # Add any text up to the '%xx' escape sequence.
+        if start_position != current_position:
+            leading_text = string[current_position:start_position]
+            parts.append(percent_encoded(leading_text, safe=safe))
+
+        # Add the '%xx' escape sequence.
+        parts.append(matched_text)
+        current_position = end_position
+
+    # Add any text after the final '%xx' escape sequence.
+    if current_position != len(string):
+        trailing_text = string[current_position:]
+        parts.append(percent_encoded(trailing_text, safe=safe))
+
+    return "".join(parts)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urls.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urls.py
new file mode 100644
index 0000000000000000000000000000000000000000..2abc2bc1ab7cb1923da1bb6da06379c699c88aa8
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_urls.py
@@ -0,0 +1,689 @@
+from __future__ import annotations
+
+import ipaddress
+import sys
+import typing
+from dataclasses import dataclass
+from urllib.parse import parse_qs, unquote, urlencode
+
+import idna
+
+if sys.version_info >= (3, 13):
+    from warnings import deprecated  # pragma: no cover
+else:
+    from typing_extensions import deprecated  # pragma: no cover
+
+from ._exceptions import HTTPXDeprecationWarning
+from ._types import QueryParamTypes
+from ._urlparse import urlparse
+from ._utils import primitive_value_to_str
+
+__all__ = ["URL", "Origin", "QueryParams"]
+
+
+class URL:
+    """
+    url = httpx2.URL("HTTPS://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink")
+
+    assert url.scheme == "https"
+    assert url.username == "jo@email.com"
+    assert url.password == "a secret"
+    assert url.userinfo == b"jo%40email.com:a%20secret"
+    assert url.host == "müller.de"
+    assert url.raw_host == b"xn--mller-kva.de"
+    assert url.port == 1234
+    assert url.netloc == b"xn--mller-kva.de:1234"
+    assert url.path == "/pa th"
+    assert url.query == b"search=ab"
+    assert url.raw_path == b"/pa%20th?search=ab"
+    assert url.fragment == "anchorlink"
+
+    The components of a URL are broken down like this:
+
+       https://jo%40email.com:a%20secret@müller.de:1234/pa%20th?search=ab#anchorlink
+    [scheme]   [  username  ] [password] [ host ][port][ path ] [ query ] [fragment]
+               [       userinfo        ] [   netloc   ][    raw_path    ]
+
+    Note that:
+
+    * `url.scheme` is normalized to always be lowercased.
+
+    * `url.host` is normalized to always be lowercased. Internationalized domain
+      names are represented in unicode, without IDNA encoding applied. For instance:
+
+      url = httpx2.URL("http://中国.icom.museum")
+      assert url.host == "中国.icom.museum"
+      url = httpx2.URL("http://xn--fiqs8s.icom.museum")
+      assert url.host == "中国.icom.museum"
+
+    * `url.raw_host` is normalized to always be lowercased, and is IDNA encoded.
+
+      url = httpx2.URL("http://中国.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+      url = httpx2.URL("http://xn--fiqs8s.icom.museum")
+      assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+    * `url.port` is either None or an integer. URLs that include the default port for
+      "http", "https", "ws", "wss", and "ftp" schemes have their port
+      normalized to `None`.
+
+      assert httpx2.URL("http://example.com") == httpx2.URL("http://example.com:80")
+      assert httpx2.URL("http://example.com").port is None
+      assert httpx2.URL("http://example.com:80").port is None
+
+    * `url.userinfo` is raw bytes, without URL escaping. Usually you'll want to work
+      with `url.username` and `url.password` instead, which handle the URL escaping.
+
+    * `url.raw_path` is raw bytes of both the path and query, without URL escaping.
+      This portion is used as the target when constructing HTTP requests. Usually you'll
+      want to work with `url.path` instead.
+
+    * `url.query` is raw bytes, without URL escaping. A URL query string portion can
+      only be properly URL escaped when decoding the parameter names and values
+      themselves.
+    """
+
+    def __init__(self, url: URL | str = "", **kwargs: typing.Any) -> None:
+        if kwargs:
+            allowed = {
+                "scheme": str,
+                "username": str,
+                "password": str,
+                "userinfo": bytes,
+                "host": str,
+                "port": int,
+                "netloc": bytes,
+                "path": str,
+                "query": bytes,
+                "raw_path": bytes,
+                "fragment": str,
+                "params": object,
+            }
+
+            # Perform type checking for all supported keyword arguments.
+            for key, value in kwargs.items():
+                if key not in allowed:
+                    message = f"{key!r} is an invalid keyword argument for URL()"
+                    raise TypeError(message)
+                if value is not None and not isinstance(value, allowed[key]):
+                    expected = allowed[key].__name__
+                    seen = type(value).__name__
+                    message = f"Argument {key!r} must be {expected} but got {seen}"
+                    raise TypeError(message)
+                if isinstance(value, bytes):
+                    kwargs[key] = value.decode("ascii")
+
+            if "params" in kwargs:
+                # Replace any "params" keyword with the raw "query" instead.
+                #
+                # Ensure that empty params use `kwargs["query"] = None` rather
+                # than `kwargs["query"] = ""`, so that generated URLs do not
+                # include an empty trailing "?".
+                params = kwargs.pop("params")
+                kwargs["query"] = None if not params else str(QueryParams(params))
+
+        if isinstance(url, str):
+            self._uri_reference = urlparse(url, **kwargs)
+        elif isinstance(url, URL):
+            self._uri_reference = url._uri_reference.copy_with(**kwargs)
+        else:
+            raise TypeError(f"Invalid type for url.  Expected str or httpx2.URL, got {type(url)}: {url!r}")
+
+    @property
+    def scheme(self) -> str:
+        """
+        The URL scheme, such as "http", "https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme
+
+    @property
+    def raw_scheme(self) -> bytes:
+        """
+        The raw bytes representation of the URL scheme, such as b"http", b"https".
+        Always normalised to lowercase.
+        """
+        return self._uri_reference.scheme.encode("ascii")
+
+    @property
+    def userinfo(self) -> bytes:
+        """
+        The URL userinfo as a raw bytestring.
+        For example: b"jo%40email.com:a%20secret".
+        """
+        return self._uri_reference.userinfo.encode("ascii")
+
+    @property
+    def username(self) -> str:
+        """
+        The URL username as a string, with URL decoding applied.
+        For example: "jo@email.com"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[0])
+
+    @property
+    def password(self) -> str:
+        """
+        The URL password as a string, with URL decoding applied.
+        For example: "a secret"
+        """
+        userinfo = self._uri_reference.userinfo
+        return unquote(userinfo.partition(":")[2])
+
+    @property
+    def host(self) -> str:
+        """
+        The URL host as a string.
+        Always normalized to lowercase, with IDNA hosts decoded into unicode.
+
+        Examples:
+
+        url = httpx2.URL("http://www.EXAMPLE.org")
+        assert url.host == "www.example.org"
+
+        url = httpx2.URL("http://中国.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx2.URL("http://xn--fiqs8s.icom.museum")
+        assert url.host == "中国.icom.museum"
+
+        url = httpx2.URL("https://[::ffff:192.168.0.1]")
+        assert url.host == "::ffff:192.168.0.1"
+        """
+        host: str = self._uri_reference.host
+
+        if "xn--" in host:
+            host = idna.decode(host, display=True)
+
+        return host
+
+    @property
+    def raw_host(self) -> bytes:
+        """
+        The raw bytes representation of the URL host.
+        Always normalized to lowercase, and IDNA encoded.
+
+        Examples:
+
+        url = httpx2.URL("http://www.EXAMPLE.org")
+        assert url.raw_host == b"www.example.org"
+
+        url = httpx2.URL("http://中国.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx2.URL("http://xn--fiqs8s.icom.museum")
+        assert url.raw_host == b"xn--fiqs8s.icom.museum"
+
+        url = httpx2.URL("https://[::ffff:192.168.0.1]")
+        assert url.raw_host == b"::ffff:192.168.0.1"
+        """
+        return self._uri_reference.host.encode("ascii")
+
+    @property
+    def port(self) -> int | None:
+        """
+        The URL port as an integer.
+
+        Note that the URL class performs port normalization as per the WHATWG spec.
+        Default ports for "http", "https", "ws", "wss", and "ftp" schemes are always
+        treated as `None`.
+
+        For example:
+
+        assert httpx2.URL("http://www.example.com") == httpx2.URL("http://www.example.com:80")
+        assert httpx2.URL("http://www.example.com:80").port is None
+        """
+        return self._uri_reference.port
+
+    @property
+    def netloc(self) -> bytes:
+        """
+        Either `<host>` or `<host>:<port>` as bytes.
+        Always normalized to lowercase, and IDNA encoded.
+
+        This property may be used for generating the value of a request
+        "Host" header.
+        """
+        return self._uri_reference.netloc.encode("ascii")
+
+    @property
+    def path(self) -> str:
+        """
+        The URL path as a string. Excluding the query string, and URL decoded.
+
+        For example:
+
+        url = httpx2.URL("https://example.com/pa%20th")
+        assert url.path == "/pa th"
+        """
+        path = self._uri_reference.path or "/"
+        return unquote(path)
+
+    @property
+    def query(self) -> bytes:
+        """
+        The URL query string, as raw bytes, excluding the leading b"?".
+
+        This is necessarily a bytewise interface, because we cannot
+        perform URL decoding of this representation until we've parsed
+        the keys and values into a QueryParams instance.
+
+        For example:
+
+        url = httpx2.URL("https://example.com/?filter=some%20search%20terms")
+        assert url.query == b"filter=some%20search%20terms"
+        """
+        query = self._uri_reference.query or ""
+        return query.encode("ascii")
+
+    @property
+    def params(self) -> QueryParams:
+        """
+        The URL query parameters, neatly parsed and packaged into an immutable
+        multidict representation.
+        """
+        return QueryParams(self._uri_reference.query)
+
+    @property
+    def raw_path(self) -> bytes:
+        """
+        The complete URL path and query string as raw bytes.
+        Used as the target when constructing HTTP requests.
+
+        For example:
+
+        GET /users?search=some%20text HTTP/1.1
+        Host: www.example.org
+        Connection: close
+        """
+        path = self._uri_reference.path or "/"
+        if self._uri_reference.query is not None:
+            path += "?" + self._uri_reference.query
+        return path.encode("ascii")
+
+    @property
+    def fragment(self) -> str:
+        """
+        The URL fragments, as used in HTML anchors.
+        As a string, without the leading '#'.
+        """
+        return unquote(self._uri_reference.fragment or "")
+
+    @property
+    def is_absolute_url(self) -> bool:
+        """
+        Return `True` for absolute URLs such as 'http://example.com/path',
+        and `False` for relative URLs such as '/path'.
+        """
+        # We don't use `.is_absolute` from `rfc3986` because it treats
+        # URLs with a fragment portion as not absolute.
+        # What we actually care about is if the URL provides
+        # a scheme and hostname to which connections should be made.
+        return bool(self._uri_reference.scheme and self._uri_reference.host)
+
+    @property
+    def is_relative_url(self) -> bool:
+        """
+        Return `False` for absolute URLs such as 'http://example.com/path',
+        and `True` for relative URLs such as '/path'.
+        """
+        return not self.is_absolute_url
+
+    @property
+    def origin(self) -> Origin:
+        """
+        The URL origin as an immutable, hashable `Origin` value.
+
+        The origin consists of the URL scheme, host, and effective port.
+        User information, path, query, and fragment components are excluded.
+        """
+        return Origin(self)
+
+    def copy_with(self, **kwargs: typing.Any) -> URL:
+        """
+        Copy this URL, returning a new URL with some components altered.
+        Accepts the same set of parameters as the components that are made
+        available via properties on the `URL` class.
+
+        For example:
+
+        url = httpx2.URL("https://www.example.com").copy_with(
+            username="jo@gmail.com", password="a secret"
+        )
+        assert url == "https://jo%40email.com:a%20secret@www.example.com"
+        """
+        return URL(self, **kwargs)
+
+    def copy_set_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.set(key, value))
+
+    def copy_add_param(self, key: str, value: typing.Any = None) -> URL:
+        return self.copy_with(params=self.params.add(key, value))
+
+    def copy_remove_param(self, key: str) -> URL:
+        return self.copy_with(params=self.params.remove(key))
+
+    def copy_merge_params(self, params: QueryParamTypes) -> URL:
+        return self.copy_with(params=self.params.merge(params))
+
+    def join(self, url: URL | str) -> URL:
+        """
+        Return an absolute URL, using this URL as the base.
+
+        Eg.
+
+        url = httpx2.URL("https://www.example.com/test")
+        url = url.join("/new/path")
+        assert url == "https://www.example.com/new/path"
+        """
+        from urllib.parse import urljoin
+
+        return URL(urljoin(str(self), str(URL(url))))
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, (URL, str)) and str(self) == str(URL(other))
+
+    def __str__(self) -> str:
+        return str(self._uri_reference)
+
+    def __repr__(self) -> str:
+        scheme, userinfo, host, port, path, query, fragment = self._uri_reference
+
+        if ":" in userinfo:
+            # Mask any password component.
+            userinfo = f"{userinfo.split(':')[0]}:[secure]"
+
+        authority = "".join(
+            [
+                f"{userinfo}@" if userinfo else "",
+                f"[{host}]" if ":" in host else host,
+                f":{port}" if port is not None else "",
+            ]
+        )
+        url = "".join(
+            [
+                f"{self.scheme}:" if scheme else "",
+                f"//{authority}" if authority else "",
+                path,
+                f"?{query}" if query is not None else "",
+                f"#{fragment}" if fragment is not None else "",
+            ]
+        )
+
+        return f"{self.__class__.__name__}({url!r})"
+
+    @property
+    @deprecated("URL.raw is deprecated.", category=HTTPXDeprecationWarning)
+    def raw(self) -> tuple[bytes, bytes, int, bytes]:  # pragma: no cover
+        import collections
+
+        RawURL = collections.namedtuple("RawURL", ["raw_scheme", "raw_host", "port", "raw_path"])
+        return RawURL(
+            raw_scheme=self.raw_scheme,
+            raw_host=self.raw_host,
+            port=self.port,
+            raw_path=self.raw_path,
+        )
+
+
+_ORIGIN_DEFAULT_PORTS = {
+    "ftp": 21,
+    "http": 80,
+    "https": 443,
+    "ws": 80,
+    "wss": 443,
+}
+
+
+@dataclass(frozen=True, slots=True, init=False)
+class Origin:
+    """
+    The scheme, host, and effective port of a URL.
+
+    Origins are normalized, immutable, comparable, and hashable.
+
+    See RFC 9110, Section 4.3.1: https://www.rfc-editor.org/rfc/rfc9110.html#name-uri-origin
+    """
+
+    scheme: str
+    host: str
+    port: int | None
+
+    def __init__(self, url: URL | str) -> None:
+        if not isinstance(url, URL):
+            url = URL(url)
+
+        if url.is_relative_url:
+            raise ValueError("URL must be absolute to have an origin")
+
+        host = url.host
+        if b":" in url.raw_host:
+            # IPv6 addresses may have multiple equivalent string forms. Store
+            # their canonical compressed form so origin equality is numeric.
+            host = str(ipaddress.IPv6Address(url.raw_host.decode("ascii")))
+
+        port = url.port
+        if port is None:
+            port = _ORIGIN_DEFAULT_PORTS.get(url.scheme)
+
+        object.__setattr__(self, "scheme", url.scheme)
+        object.__setattr__(self, "host", host)
+        object.__setattr__(self, "port", port)
+
+
+class QueryParams(typing.Mapping[str, str]):
+    """
+    URL query parameters, as a multi-dict.
+    """
+
+    def __init__(self, *args: QueryParamTypes | None, **kwargs: typing.Any) -> None:
+        assert len(args) < 2, "Too many arguments."
+        assert not (args and kwargs), "Cannot mix named and unnamed arguments."
+
+        value = args[0] if args else kwargs
+
+        if value is None or isinstance(value, (str, bytes)):
+            value = value.decode("ascii") if isinstance(value, bytes) else value
+            self._dict = parse_qs(value, keep_blank_values=True)
+        elif isinstance(value, QueryParams):
+            self._dict = {k: list(v) for k, v in value._dict.items()}
+        else:
+            dict_value: dict[typing.Any, list[typing.Any]] = {}
+            if isinstance(value, (list, tuple)):
+                # Convert list inputs like:
+                #     [("a", "123"), ("a", "456"), ("b", "789")]
+                # To a dict representation, like:
+                #     {"a": ["123", "456"], "b": ["789"]}
+                for item in value:
+                    dict_value.setdefault(item[0], []).append(item[1])
+            else:
+                # Convert dict inputs like:
+                #    {"a": "123", "b": ["456", "789"]}
+                # To dict inputs where values are always lists, like:
+                #    {"a": ["123"], "b": ["456", "789"]}
+                dict_value = {k: list(v) if isinstance(v, (list, tuple)) else [v] for k, v in value.items()}
+
+            # Ensure that keys and values are neatly coerced to strings.
+            # We coerce values `True` and `False` to JSON-like "true" and "false"
+            # representations, and coerce `None` values to the empty string.
+            self._dict = {str(k): [primitive_value_to_str(item) for item in v] for k, v in dict_value.items()}
+
+    def keys(self) -> typing.KeysView[str]:
+        """
+        Return all the keys in the query params.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert list(q.keys()) == ["a", "b"]
+        """
+        return self._dict.keys()
+
+    def values(self) -> typing.ValuesView[str]:
+        """
+        Return all the values in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert list(q.values()) == ["123", "789"]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.values()
+
+    def items(self) -> typing.ItemsView[str, str]:
+        """
+        Return all items in the query params. If a key occurs more than once
+        only the first item for that key is returned.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert list(q.items()) == [("a", "123"), ("b", "789")]
+        """
+        return {k: v[0] for k, v in self._dict.items()}.items()
+
+    def multi_items(self) -> list[tuple[str, str]]:
+        """
+        Return all items in the query params. Allow duplicate keys to occur.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert list(q.multi_items()) == [("a", "123"), ("a", "456"), ("b", "789")]
+        """
+        multi_items: list[tuple[str, str]] = []
+        for k, v in self._dict.items():
+            multi_items.extend([(k, i) for i in v])
+        return multi_items
+
+    def get(self, key: typing.Any, default: typing.Any = None) -> typing.Any:
+        """
+        Get a value from the query param for a given key. If the key occurs
+        more than once, then only the first value is returned.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert q.get("a") == "123"
+        """
+        if key in self._dict:
+            return self._dict[str(key)][0]
+        return default
+
+    def get_list(self, key: str) -> list[str]:
+        """
+        Get all values from the query param for a given key.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123&a=456&b=789")
+        assert q.get_list("a") == ["123", "456"]
+        """
+        return list(self._dict.get(str(key), []))
+
+    def set(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting the value of a key.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123")
+        q = q.set("a", "456")
+        assert q == httpx2.QueryParams("a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = [primitive_value_to_str(value)]
+        return q
+
+    def add(self, key: str, value: typing.Any = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, setting or appending the value of a key.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123")
+        q = q.add("a", "456")
+        assert q == httpx2.QueryParams("a=123&a=456")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict[str(key)] = q.get_list(key) + [primitive_value_to_str(value)]
+        return q
+
+    def remove(self, key: str) -> QueryParams:
+        """
+        Return a new QueryParams instance, removing the value of a key.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123")
+        q = q.remove("a")
+        assert q == httpx2.QueryParams("")
+        """
+        q = QueryParams()
+        q._dict = dict(self._dict)
+        q._dict.pop(str(key), None)
+        return q
+
+    def merge(self, params: QueryParamTypes | None = None) -> QueryParams:
+        """
+        Return a new QueryParams instance, updated with.
+
+        Usage:
+
+        q = httpx2.QueryParams("a=123")
+        q = q.merge({"b": "456"})
+        assert q == httpx2.QueryParams("a=123&b=456")
+
+        q = httpx2.QueryParams("a=123")
+        q = q.merge({"a": "456", "b": "789"})
+        assert q == httpx2.QueryParams("a=456&b=789")
+        """
+        q = QueryParams(params)
+        q._dict = {**self._dict, **q._dict}
+        return q
+
+    def __getitem__(self, key: typing.Any) -> str:
+        return self._dict[key][0]
+
+    def __contains__(self, key: typing.Any) -> bool:
+        return key in self._dict
+
+    def __iter__(self) -> typing.Iterator[typing.Any]:
+        return iter(self.keys())
+
+    def __len__(self) -> int:
+        return len(self._dict)
+
+    def __bool__(self) -> bool:
+        return bool(self._dict)
+
+    def __hash__(self) -> int:
+        return hash(str(self))
+
+    def __eq__(self, other: typing.Any) -> bool:
+        if not isinstance(other, self.__class__):
+            return False
+        return sorted(self.multi_items()) == sorted(other.multi_items())
+
+    def __str__(self) -> str:
+        return urlencode(self.multi_items())
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        query_string = str(self)
+        return f"{class_name}({query_string!r})"
+
+    def update(self, params: QueryParamTypes | None = None) -> None:
+        raise RuntimeError("QueryParams are immutable since 0.18.0. Use `q = q.merge(...)` to create an updated copy.")
+
+    def __setitem__(self, key: str, value: str) -> None:
+        raise RuntimeError(
+            "QueryParams are immutable since 0.18.0. Use `q = q.set(key, value)` to create an updated copy."
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_utils.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef8e986ea70a0eebe9a300890603fdcbb9e2be20
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/_utils.py
@@ -0,0 +1,282 @@
+from __future__ import annotations
+
+import ipaddress
+import os
+import re
+import typing
+from urllib.request import getproxies
+
+from ._exceptions import InvalidURL
+from ._types import PrimitiveData
+
+if typing.TYPE_CHECKING:
+    from ._urls import URL
+
+
+def primitive_value_to_str(value: PrimitiveData) -> str:
+    """
+    Coerce a primitive data type into a string value.
+
+    Note that we prefer JSON-style 'true'/'false' for boolean values here.
+    """
+    if value is True:
+        return "true"
+    elif value is False:
+        return "false"
+    elif value is None:
+        return ""
+    return str(value)
+
+
+def get_environment_proxies() -> dict[str, str | None]:
+    """Gets proxy information from the environment"""
+
+    # urllib.request.getproxies() falls back on System
+    # Registry and Config for proxies on Windows and macOS.
+    # We don't want to propagate non-HTTP proxies into
+    # our configuration such as 'TRAVIS_APT_PROXY'.
+    proxy_info = getproxies()
+    mounts: dict[str, str | None] = {}
+
+    for scheme in ("http", "https", "all"):
+        if proxy_info.get(scheme):
+            hostname = proxy_info[scheme]
+            mounts[f"{scheme}://"] = hostname if "://" in hostname else f"http://{hostname}"
+
+    no_proxy_hosts = [host.strip() for host in proxy_info.get("no", "").split(",")]
+    for hostname in no_proxy_hosts:
+        # See https://curl.haxx.se/libcurl/c/CURLOPT_NOPROXY.html for details
+        # on how names in `NO_PROXY` are handled.
+        if hostname == "*":
+            # If NO_PROXY=* is used or if "*" occurs as any one of the comma
+            # separated hostnames, then we should just bypass any information
+            # from HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, and always ignore
+            # proxies.
+            return {}
+        elif hostname:
+            # NO_PROXY=.google.com is marked as "all://*.google.com,
+            #   which disables "www.google.com" but not "google.com"
+            # NO_PROXY=google.com is marked as "all://*google.com,
+            #   which disables "www.google.com" and "google.com".
+            #   (But not "wwwgoogle.com")
+            # NO_PROXY can include domains, IPv6, IPv4 addresses and "localhost"
+            #   NO_PROXY=example.com,::1,localhost,192.168.0.0/16
+            if "://" in hostname:
+                mounts[hostname] = None
+            elif is_ipv4_hostname(hostname):
+                mounts[f"all://{hostname}"] = None
+            elif is_ipv6_hostname(hostname):
+                if "/" in hostname:
+                    addr, _, subnet = hostname.partition("/")
+                    mounts[f"all://[{addr}]/{subnet}"] = None
+                else:
+                    mounts[f"all://[{hostname}]"] = None
+            elif hostname.lower() == "localhost":
+                mounts[f"all://{hostname}"] = None
+            elif hostname.startswith("["):
+                mounts[f"all://{hostname}"] = None
+            elif "/" not in hostname:
+                mounts[f"all://*{hostname}"] = None
+
+    for pattern in list(mounts):
+        try:
+            URLPattern(pattern)
+        except InvalidURL:
+            del mounts[pattern]  # Like curl and Go, ignore entries that cannot be parsed.
+
+    return mounts
+
+
+def to_bytes(value: str | bytes, encoding: str = "utf-8") -> bytes:
+    return value.encode(encoding) if isinstance(value, str) else value
+
+
+def to_str(value: str | bytes, encoding: str = "utf-8") -> str:
+    return value if isinstance(value, str) else value.decode(encoding)
+
+
+def to_bytes_or_str(value: str, match_type_of: typing.AnyStr) -> typing.AnyStr:
+    return value if isinstance(match_type_of, str) else value.encode()
+
+
+def peek_filelike_length(stream: typing.Any) -> int | None:
+    """
+    Given a file-like stream object, return its length in number of bytes
+    without reading it into memory.
+    """
+    try:
+        # Is it an actual file?
+        fd = stream.fileno()
+        # Yup, seems to be an actual file.
+        length = os.fstat(fd).st_size
+    except (AttributeError, OSError):
+        # No... Maybe it's something that supports random access, like `io.BytesIO`?
+        try:
+            # Assuming so, go to end of stream to figure out its length,
+            # then put it back in place.
+            offset = stream.tell()
+            length = stream.seek(0, os.SEEK_END)
+            stream.seek(offset)
+        except (AttributeError, OSError):
+            # Not even that? Sorry, we're doomed...
+            return None
+
+    return length
+
+
+def peek_filelike_remaining_length(stream: typing.Any) -> int | None:
+    """Return the remaining byte length without changing the stream position."""
+    try:
+        offset: int = stream.tell()
+        length: int = stream.seek(0, os.SEEK_END)
+        stream.seek(offset)
+    except (AttributeError, OSError):
+        return None
+
+    return max(0, length - offset)
+
+
+class URLPattern:
+    """
+    A utility class currently used for making lookups against proxy keys...
+
+    # Wildcard matching...
+    >>> pattern = URLPattern("all://")
+    >>> pattern.matches(httpx2.URL("http://example.com"))
+    True
+
+    # Witch scheme matching...
+    >>> pattern = URLPattern("https://")
+    >>> pattern.matches(httpx2.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx2.URL("http://example.com"))
+    False
+
+    # With domain matching...
+    >>> pattern = URLPattern("https://example.com")
+    >>> pattern.matches(httpx2.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx2.URL("http://example.com"))
+    False
+    >>> pattern.matches(httpx2.URL("https://other.com"))
+    False
+
+    # Wildcard scheme, with domain matching...
+    >>> pattern = URLPattern("all://example.com")
+    >>> pattern.matches(httpx2.URL("https://example.com"))
+    True
+    >>> pattern.matches(httpx2.URL("http://example.com"))
+    True
+    >>> pattern.matches(httpx2.URL("https://other.com"))
+    False
+
+    # With port matching...
+    >>> pattern = URLPattern("https://example.com:1234")
+    >>> pattern.matches(httpx2.URL("https://example.com:1234"))
+    True
+    >>> pattern.matches(httpx2.URL("https://example.com"))
+    False
+    """
+
+    def __init__(self, pattern: str) -> None:
+        from ._urls import URL
+
+        if pattern and ":" not in pattern:
+            raise ValueError(
+                f"Proxy keys should use proper URL forms rather "
+                f"than plain scheme strings. "
+                f'Instead of "{pattern}", use "{pattern}://"'
+            )
+
+        url = URL(pattern)
+        self.network = None
+        prefix = url.path.removeprefix("/")
+        if prefix and (is_ipv4_hostname(url.host) or is_ipv6_hostname(url.host)):
+            # A CIDR-style host, e.g. "all://192.168.0.0/16" or "all://[::1]/64".
+            host = f"[{url.host}]" if ":" in url.host else url.host
+            if "@" in pattern or "%" in pattern or not prefix.isdigit() or not pattern.endswith(f"{host}/{prefix}"):
+                raise InvalidURL(f"Invalid network in {pattern!r}")
+            try:
+                self.network = ipaddress.ip_network(f"{url.host}/{prefix}", strict=False)
+            except ValueError as exc:
+                raise InvalidURL(f"Invalid network in {pattern!r}") from exc
+
+        self.pattern = pattern
+        self.scheme = "" if url.scheme == "all" else url.scheme
+        self.host = "" if url.host == "*" else url.host
+        self.port = url.port
+        if self.network is not None:
+            self.host_regex: typing.Pattern[str] | None = None
+        elif not url.host or url.host == "*":
+            self.host_regex = None
+        elif url.host.startswith("*."):
+            # *.example.com should match "www.example.com", but not "example.com"
+            domain = re.escape(url.host[2:])
+            self.host_regex = re.compile(f"^.+\\.{domain}$")
+        elif url.host.startswith("*"):
+            # *example.com should match "www.example.com" and "example.com"
+            domain = re.escape(url.host[1:])
+            self.host_regex = re.compile(f"^(.+\\.)?{domain}$")
+        else:
+            # example.com should match "example.com" but not "www.example.com"
+            domain = re.escape(url.host)
+            self.host_regex = re.compile(f"^{domain}$")
+
+    def matches(self, other: URL) -> bool:
+        if self.scheme and self.scheme != other.scheme:
+            return False
+        if self.network is not None:
+            try:
+                other_address = ipaddress.ip_address(other.host)
+            except ValueError:
+                return False
+            if other_address not in self.network:
+                return False
+        elif self.host and self.host_regex is not None and not self.host_regex.match(other.host):
+            return False
+        if self.port is not None and self.port != other.port:
+            return False
+        return True
+
+    @property
+    def priority(self) -> tuple[int, int, int, int, int]:
+        """
+        The priority allows URLPattern instances to be sortable, so that
+        we can match from most specific to least specific.
+        """
+        # URLs with a port should take priority over URLs without a port.
+        port_priority = 0 if self.port is not None else 1
+        # Exact hosts match first, then networks, then patterns without a host.
+        host_kind_priority = 1 if self.network is not None else 0 if self.host else 2
+        # Smaller networks match first. Address count, not prefix length, so IPv4 and IPv6 compare fairly.
+        network_priority = self.network.num_addresses if self.network is not None else 0
+        # Longer hostnames should match first. Networks are already ordered by size.
+        host_priority = -len(self.host) if self.network is None else 0
+        # Longer schemes should match first.
+        scheme_priority = -len(self.scheme)
+        return (port_priority, host_kind_priority, network_priority, host_priority, scheme_priority)
+
+    def __hash__(self) -> int:
+        return hash(self.pattern)
+
+    def __lt__(self, other: URLPattern) -> bool:
+        return self.priority < other.priority
+
+    def __eq__(self, other: typing.Any) -> bool:
+        return isinstance(other, URLPattern) and self.pattern == other.pattern
+
+
+def is_ipv4_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv4Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
+
+
+def is_ipv6_hostname(hostname: str) -> bool:
+    try:
+        ipaddress.IPv6Address(hostname.split("/")[0])
+    except Exception:
+        return False
+    return True
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/py.typed b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/py.typed
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8545b0912f9ef8643e9f8caf1bf58c573c11dcc3
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__init__.py
@@ -0,0 +1,57 @@
+"""
+WebSocket support, derived from httpx-ws (https://github.com/frankie567/httpx-ws).
+
+```
+MIT License
+
+Copyright (c) 2021 François Voron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+"""
+
+from ._api import (
+    AsyncWebSocketClient,
+    AsyncWebSocketSession,
+    JSONMode,
+    WebSocketClient,
+    WebSocketSession,
+)
+from ._exceptions import (
+    HTTPXWSException,
+    WebSocketDisconnect,
+    WebSocketInvalidTypeReceived,
+    WebSocketNetworkError,
+    WebSocketUpgradeError,
+)
+from ._transport import ASGIWebSocketTransport
+
+__all__ = [
+    "ASGIWebSocketTransport",
+    "AsyncWebSocketClient",
+    "AsyncWebSocketSession",
+    "HTTPXWSException",
+    "JSONMode",
+    "WebSocketClient",
+    "WebSocketDisconnect",
+    "WebSocketInvalidTypeReceived",
+    "WebSocketNetworkError",
+    "WebSocketSession",
+    "WebSocketUpgradeError",
+]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..49f9645737e9789cb44c07f0bafeb42f0da4eb8b
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..31fca46be6ba3196ee2760be11f28985b2d86aa6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_exceptions.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_exceptions.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3aa6eeed25bf0f2816ae06bf0ddcafa7ed27cfcc
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_exceptions.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_ping.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_ping.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..df33caa0478cd36646e660695e4f741c316cc738
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_ping.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_transport.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_transport.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10fbb5cc0ac84fb4105194f070361398eb8683a5
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/__pycache__/_transport.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..26eed4ee80e081b37404e7a1cbe0b2153278d200
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_api.py
@@ -0,0 +1,1676 @@
+from __future__ import annotations
+
+import base64
+import concurrent.futures
+import contextlib
+import json
+import queue
+import secrets
+import sys
+import threading
+import typing
+from types import TracebackType
+
+if sys.version_info >= (3, 13):
+    from queue import ShutDown as QueueShutDown  # pragma: no cover
+    from typing import TypeVar  # pragma: no cover
+else:
+    from typing_extensions import TypeVar  # pragma: no cover
+
+    class QueueShutDown(Exception):  # pragma: no cover
+        """Stand-in for `queue.ShutDown`, which is never raised before Python 3.13."""
+
+
+import anyio
+import wsproto
+import wsproto.utilities
+from anyio.streams.memory import MemoryObjectReceiveStream, MemoryObjectSendStream
+from wsproto.frame_protocol import CloseReason
+
+from .._client import USE_CLIENT_DEFAULT
+from .._config import (
+    DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+    DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    DEFAULT_QUEUE_SIZE,
+)
+from .._models import Headers
+from ._exceptions import (
+    HTTPXWSException,
+    WebSocketDisconnect,
+    WebSocketInvalidTypeReceived,
+    WebSocketNetworkError,
+    WebSocketUpgradeError,
+)
+from ._ping import AsyncPingManager, PingManager
+from ._transport import ASGIWebSocketAsyncNetworkStream
+
+if typing.TYPE_CHECKING:
+    from httpcore2 import AsyncNetworkStream, NetworkStream
+
+    from .._client import AsyncClient, Client, UseClientDefault
+    from .._models import Response
+    from .._types import (
+        AuthTypes,
+        CookieTypes,
+        HeaderTypes,
+        QueryParamTypes,
+        RequestExtensions,
+        TimeoutTypes,
+    )
+
+JSONMode = typing.Literal["text", "binary"]
+TaskFunction = typing.TypeVar("TaskFunction")
+TaskResult = typing.TypeVar("TaskResult")
+SyncSession = TypeVar("SyncSession", bound="WebSocketSession", default="WebSocketSession")
+AsyncSession = TypeVar("AsyncSession", bound="AsyncWebSocketSession", default="AsyncWebSocketSession")
+
+
+class ShouldClose(Exception):
+    pass
+
+
+class EndOfStream(Exception):
+    pass
+
+
+class WebSocketSession:
+    """
+    Sync context manager representing an opened WebSocket session.
+
+    Attributes:
+        subprotocol (typing.Optional[str]):
+            Optional protocol that has been accepted by the server.
+        response (Response | None):
+            The webSocket handshake response.
+    """
+
+    subprotocol: str | None
+    response: Response | None
+
+    def __init__(
+        self,
+        stream: NetworkStream,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        response: Response | None = None,
+    ) -> None:
+        self.stream = stream
+        self.connection = wsproto.connection.Connection(wsproto.ConnectionType.CLIENT)
+        self.response = response
+        if self.response is not None:
+            self.subprotocol = self.response.headers.get("sec-websocket-protocol")
+        else:
+            self.subprotocol = None
+
+        self._events: queue.Queue[wsproto.events.Event | HTTPXWSException] = queue.Queue(queue_size)
+
+        self._ping_manager = PingManager()
+        self._should_close = threading.Event()
+        self._write_lock = threading.Lock()
+        self._should_close_task: concurrent.futures.Future[bool] | None = None
+        self._executor: concurrent.futures.ThreadPoolExecutor | None = None
+
+        self._max_message_size_bytes = max_message_size_bytes
+        self._queue_size = queue_size
+        self._keepalive_ping_interval_seconds = keepalive_ping_interval_seconds
+        self._keepalive_ping_timeout_seconds = keepalive_ping_timeout_seconds
+
+    def _get_executor_should_close_task(
+        self,
+    ) -> tuple[concurrent.futures.ThreadPoolExecutor, concurrent.futures.Future[bool]]:
+        if self._should_close_task is None:
+            self._executor = concurrent.futures.ThreadPoolExecutor()
+            self._should_close_task = self._executor.submit(self._should_close.wait)
+        assert self._executor is not None
+        return self._executor, self._should_close_task
+
+    def __enter__(self) -> WebSocketSession:
+        self._background_receive_task = threading.Thread(
+            target=self._background_receive, args=(self._max_message_size_bytes,)
+        )
+        self._background_receive_task.start()
+
+        self._background_keepalive_ping_task: threading.Thread | None = None
+        if self._keepalive_ping_interval_seconds is not None:
+            self._background_keepalive_ping_task = threading.Thread(
+                target=self._background_keepalive_ping,
+                args=(
+                    self._keepalive_ping_interval_seconds,
+                    self._keepalive_ping_timeout_seconds,
+                ),
+            )
+            self._background_keepalive_ping_task.start()
+
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        self.close()
+        # A task blocked on a full events queue only exits once there's room, or the queue shuts down.
+        if sys.version_info >= (3, 13):  # pragma: no cover - Python 3.13+ only
+            self._events.shutdown(immediate=True)
+            self._background_receive_task.join()
+            if self._background_keepalive_ping_task is not None:
+                self._background_keepalive_ping_task.join()
+        else:  # pragma: no cover - Python < 3.13 only
+            for task in (self._background_receive_task, self._background_keepalive_ping_task):
+                while task is not None and task.is_alive():
+                    with contextlib.suppress(queue.Empty):
+                        self._events.get(timeout=0.01)
+
+    def ping(self, payload: bytes = b"") -> threading.Event:
+        """
+        Send a Ping message.
+
+        Args:
+            payload:
+                Payload to attach to the Ping event.
+                Internally, it's used to track this specific event.
+                If left empty, a random one will be generated.
+
+        Returns:
+            An event that can be used to wait for the corresponding Pong response.
+
+        Examples:
+            Send a Ping and wait for the Pong
+
+                pong_callback = ws.ping()
+                # Will block until the corresponding Pong is received.
+                pong_callback.wait()
+        """
+        ping_id, callback = self._ping_manager.create(payload)
+        event = wsproto.events.Ping(ping_id)
+        self.send(event)
+        return callback
+
+    def send(self, event: wsproto.events.Event) -> None:
+        """
+        Send an Event message.
+
+        Mainly useful to send events that are not supported by the library.
+        Most of the time, [ping()][httpx_ws.WebSocketSession.ping],
+        [send_text()][httpx_ws.WebSocketSession.send_text],
+        [send_bytes()][httpx_ws.WebSocketSession.send_bytes]
+        and [send_json()][httpx_ws.WebSocketSession.send_json] are preferred.
+
+        Args:
+            event: The event to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Examples:
+            Send an event.
+
+                event = wsproto.events.Message(b"Hello!")
+                ws.send(event)
+        """
+        import httpcore2
+
+        try:
+            data = self.connection.send(event)
+            with self._write_lock:
+                self.stream.write(data)
+        except httpcore2.WriteError as e:
+            self.close(CloseReason.INTERNAL_ERROR, "Stream write error")
+            raise WebSocketNetworkError() from e
+
+    def send_text(self, data: str) -> None:
+        """
+        Send a text message.
+
+        Args:
+            data: The text to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Examples:
+            Send a text message.
+
+                ws.send_text("Hello!")
+        """
+        event = wsproto.events.TextMessage(data=data)
+        self.send(event)
+
+    def send_bytes(self, data: bytes) -> None:
+        """
+        Send a bytes message.
+
+        Args:
+            data: The data to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Examples:
+            Send a bytes message.
+
+                ws.send_bytes(b"Hello!")
+        """
+        event = wsproto.events.BytesMessage(data=data)
+        self.send(event)
+
+    def send_json(self, data: typing.Any, mode: JSONMode = "text") -> None:
+        """
+        Send JSON data.
+
+        Args:
+            data:
+                The data to send. Must be serializable by [json.dumps][json.dumps].
+            mode:
+                The sending mode. Should either be `'text'` or `'bytes'`.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Examples:
+            Send JSON data.
+
+                data = {"message": "Hello!"}
+                ws.send_json(data)
+        """
+        assert mode in ["text", "binary"]
+        serialized_data = json.dumps(data)
+        if mode == "text":
+            self.send_text(serialized_data)
+        else:
+            self.send_bytes(serialized_data.encode("utf-8"))
+
+    def receive(self, timeout: float | None = None) -> wsproto.events.Event:
+        """
+        Receive an event from the server.
+
+        Mainly useful to receive raw [wsproto.events.Event][wsproto.events.Event].
+        Most of the time, [receive_text()][httpx_ws.WebSocketSession.receive_text],
+        [receive_bytes()][httpx_ws.WebSocketSession.receive_bytes],
+        and [receive_json()][httpx_ws.WebSocketSession.receive_json] are preferred.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            A raw [wsproto.events.Event][wsproto.events.Event].
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+
+        Examples:
+            Wait for an event until one is available.
+
+                try:
+                    event = ws.receive()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for an event for 2 seconds.
+
+                try:
+                    event = ws.receive(timeout=2.)
+                except TimeoutError:
+                    print("No event received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        try:
+            event = self._events.get(block=True, timeout=timeout)
+        except queue.Empty as e:
+            raise TimeoutError from e
+        except QueueShutDown as e:  # pragma: no cover - Python 3.13+ only
+            raise WebSocketDisconnect() from e
+        if isinstance(event, HTTPXWSException):
+            raise event
+        if isinstance(event, wsproto.events.CloseConnection):
+            raise WebSocketDisconnect(event.code, event.reason)
+        return event
+
+    def receive_text(self, timeout: float | None = None) -> str:
+        """
+        Receive text from the server.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            Text data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event was not a text message.
+
+        Examples:
+            Wait for text until available.
+
+                try:
+                    text = ws.receive_text()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for text for 2 seconds.
+
+                try:
+                    event = ws.receive_text(timeout=2.)
+                except TimeoutError:
+                    print("No text received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        event = self.receive(timeout)
+        if isinstance(event, wsproto.events.TextMessage):
+            return event.data
+        raise WebSocketInvalidTypeReceived(event)
+
+    def receive_bytes(self, timeout: float | None = None) -> bytes:
+        """
+        Receive bytes from the server.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            Bytes data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event was not a bytes message.
+
+        Examples:
+            Wait for bytes until available.
+
+                try:
+                    data = ws.receive_bytes()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for bytes for 2 seconds.
+
+                try:
+                    data = ws.receive_bytes(timeout=2.)
+                except TimeoutError:
+                    print("No data received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        event = self.receive(timeout)
+        if isinstance(event, wsproto.events.BytesMessage):
+            return bytes(event.data)
+        raise WebSocketInvalidTypeReceived(event)
+
+    def receive_json(self, timeout: float | None = None, mode: JSONMode = "text") -> typing.Any:
+        """
+        Receive JSON data from the server.
+
+        The received data should be parseable by [json.loads][json.loads].
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+            mode:
+                Receive mode. Should either be `'text'` or `'bytes'`.
+
+        Returns:
+            Parsed JSON data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event
+                didn't correspond to the specified mode.
+
+        Examples:
+            Wait for data until available.
+
+                try:
+                    data = ws.receive_json()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for data for 2 seconds.
+
+                try:
+                    data = ws.receive_json(timeout=2.)
+                except TimeoutError:
+                    print("No data received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        assert mode in ["text", "binary"]
+        data: str | bytes
+        if mode == "text":
+            data = self.receive_text(timeout)
+        elif mode == "binary":
+            data = self.receive_bytes(timeout)
+        return json.loads(data)
+
+    def close(self, code: int = 1000, reason: str | None = None) -> None:
+        """
+        Close the WebSocket session.
+
+        Internally, it'll send the
+        [CloseConnection][wsproto.events.CloseConnection] event.
+
+        *This method is automatically called when exiting the context manager.*
+
+        Args:
+            code:
+                The integer close code to indicate why the connection has closed.
+            reason:
+                Additional reasoning for why the connection has closed.
+
+        Examples:
+            Close the WebSocket session.
+
+                ws.close()
+        """
+        import httpcore2
+
+        self._should_close.set()
+        if self._executor is not None:
+            self._executor.shutdown(False)
+        if self.connection.state not in {
+            wsproto.connection.ConnectionState.LOCAL_CLOSING,
+            wsproto.connection.ConnectionState.CLOSED,
+        }:
+            event = wsproto.events.CloseConnection(code, reason)
+            data = self.connection.send(event)
+            try:
+                with self._write_lock:
+                    self.stream.write(data)
+            except httpcore2.WriteError:
+                pass
+        self.stream.close()
+
+    def _background_receive(self, max_bytes: int) -> None:
+        """
+        Background thread listening for data from the server.
+
+        Internally, it'll:
+
+        * Answer to Ping events.
+        * Acknowledge Pong events.
+        * Put other events in the [_events][_events]
+        queue that'll eventually be consumed by the user.
+
+        Args:
+            max_bytes: The maximum chunk size to read at each iteration.
+        """
+        import httpcore2
+
+        partial_message_buffer: str | bytes | None = None
+        partial_message_size = 0
+        try:
+            while not self._should_close.is_set():
+                data = self._wait_until_closed(self._read_stream, max_bytes)
+                self.connection.receive_data(data)
+                for event in self.connection.events():
+                    if isinstance(event, wsproto.events.Ping):
+                        data = self.connection.send(event.response())
+                        with self._write_lock:
+                            self.stream.write(data)
+                        continue
+                    if isinstance(event, wsproto.events.Pong):
+                        self._ping_manager.ack(event.payload)
+                        continue
+                    if isinstance(event, wsproto.events.CloseConnection):
+                        self._should_close.set()
+                    if isinstance(event, wsproto.events.Message):
+                        partial_message_size += len(event.data.encode() if isinstance(event.data, str) else event.data)
+                        if partial_message_size > max_bytes:
+                            self.close(CloseReason.MESSAGE_TOO_BIG, "Message too big")
+                            self._events.put(WebSocketDisconnect(CloseReason.MESSAGE_TOO_BIG, "Message too big"))
+                            break
+                        # Unfinished message: bufferize
+                        if not event.message_finished:
+                            if partial_message_buffer is None:
+                                partial_message_buffer = event.data
+                            else:
+                                partial_message_buffer += event.data
+                        # Finished message but no buffer: just emit the event
+                        elif partial_message_buffer is None:
+                            partial_message_size = 0
+                            self._events.put(event)
+                        # Finished message with buffer: emit the full event
+                        else:
+                            event_type = type(event)
+                            full_message_event = event_type(partial_message_buffer + event.data)
+                            partial_message_buffer = None
+                            partial_message_size = 0
+                            self._events.put(full_message_event)
+                        continue
+                    self._events.put(event)
+        except (httpcore2.ReadError, httpcore2.WriteError, EndOfStream):
+            self.close(CloseReason.INTERNAL_ERROR, "Stream error")
+            with contextlib.suppress(QueueShutDown):
+                self._events.put(WebSocketNetworkError())
+        except (ShouldClose, QueueShutDown):
+            pass
+
+    def _background_keepalive_ping(self, interval_seconds: float, timeout_seconds: float | None = None) -> None:
+        try:
+            while not self._should_close.is_set():
+                should_close = self._wait_until_closed(self._should_close.wait, interval_seconds)
+                if should_close:  # pragma: no cover
+                    raise ShouldClose()
+                try:
+                    pong_callback = self.ping()
+                except wsproto.utilities.LocalProtocolError:
+                    return
+                if timeout_seconds is not None:
+                    acknowledged = self._wait_until_closed(pong_callback.wait, timeout_seconds)
+                    if not acknowledged:
+                        self.close(CloseReason.INTERNAL_ERROR, "Keepalive ping timeout")
+                        self._events.put(WebSocketNetworkError())
+        except (ShouldClose, QueueShutDown):
+            pass
+
+    def _wait_until_closed(
+        self, callable: typing.Callable[..., TaskResult], *args: typing.Any, **kwargs: typing.Any
+    ) -> TaskResult:
+        try:
+            executor, should_close_task = self._get_executor_should_close_task()
+            todo_task = executor.submit(callable, *args, **kwargs)
+        except RuntimeError as e:
+            raise ShouldClose() from e
+        else:
+            done, _ = concurrent.futures.wait(
+                (todo_task, should_close_task),  # type: ignore[misc]
+                return_when=concurrent.futures.FIRST_COMPLETED,
+            )
+            if should_close_task in done:
+                raise ShouldClose()
+            assert todo_task in done
+            result = todo_task.result()
+        return result
+
+    def _read_stream(self, max_bytes: int) -> bytes:
+        data = self.stream.read(max_bytes)
+        if data == b"":
+            raise EndOfStream()
+        return data
+
+
+class AsyncWebSocketSession(anyio.AsyncContextManagerMixin):
+    """
+    Async context manager representing an opened WebSocket session.
+
+    Internally, this session uses an anyio task group to manage background tasks.
+    As a result, exceptions that are not caught inside the context manager
+    and propagate out of the `async with` block will be wrapped
+    in an [ExceptionGroup][ExceptionGroup].
+
+    To handle them, use the `except*` syntax:
+
+        async with AsyncWebSocketSession(stream) as ws:
+            try:
+                data = await ws.receive_text()
+            except WebSocketDisconnect:
+                # Caught inside the context manager: plain exception.
+                print("Connection closed")
+
+        # If not caught inside:
+        try:
+            async with AsyncWebSocketSession(stream) as ws:
+                data = await ws.receive_text()
+        except* WebSocketDisconnect:
+            # Propagated out of the context manager: wrapped in ExceptionGroup.
+            print("Connection closed")
+
+    Attributes:
+        subprotocol (typing.Optional[str]):
+            Optional protocol that has been accepted by the server.
+        response (Response | None):
+            The webSocket handshake response.
+    """
+
+    subprotocol: str | None
+    response: Response | None
+    _send_event: MemoryObjectSendStream[wsproto.events.Event | HTTPXWSException]
+    _receive_event: MemoryObjectReceiveStream[wsproto.events.Event | HTTPXWSException]
+
+    def __init__(
+        self,
+        stream: AsyncNetworkStream,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        response: Response | None = None,
+    ) -> None:
+        self.stream = stream
+        self.connection = wsproto.connection.Connection(wsproto.ConnectionType.CLIENT)
+        self.response = response
+        if self.response is not None:
+            self.subprotocol = self.response.headers.get("sec-websocket-protocol")
+        else:
+            self.subprotocol = None
+
+        self._ping_manager = AsyncPingManager()
+        self._should_close = anyio.Event()
+        self._write_lock = anyio.Lock()
+
+        self._max_message_size_bytes = max_message_size_bytes
+        self._queue_size = queue_size
+
+        # Always disable keepalive ping when emulating ASGI
+        if isinstance(stream, ASGIWebSocketAsyncNetworkStream):
+            self._keepalive_ping_interval_seconds = None
+            self._keepalive_ping_timeout_seconds = None
+        else:
+            self._keepalive_ping_interval_seconds = keepalive_ping_interval_seconds
+            self._keepalive_ping_timeout_seconds = keepalive_ping_timeout_seconds
+
+    @contextlib.asynccontextmanager
+    async def __asynccontextmanager__(self) -> typing.AsyncGenerator[AsyncWebSocketSession, None]:
+        self._send_event, self._receive_event = anyio.create_memory_object_stream[
+            wsproto.events.Event | HTTPXWSException
+        ]()
+        self._background_task_group = anyio.create_task_group()
+
+        async with self._send_event, self._receive_event, self._background_task_group:
+            self._background_task_group.start_soon(self._background_receive, self._max_message_size_bytes)
+            if self._keepalive_ping_interval_seconds is not None:
+                self._background_task_group.start_soon(
+                    self._background_keepalive_ping,
+                    self._keepalive_ping_interval_seconds,
+                    self._keepalive_ping_timeout_seconds,
+                )
+
+            try:
+                yield self
+            finally:
+                self._background_task_group.cancel_scope.cancel()
+                with anyio.CancelScope(shield=True):
+                    await self.close()
+
+    async def ping(self, payload: bytes = b"") -> anyio.Event:
+        """
+        Send a Ping message.
+
+        Args:
+            payload:
+                Payload to attach to the Ping event.
+                Internally, it's used to track this specific event.
+                If left empty, a random one will be generated.
+
+        Returns:
+            An event that can be used to wait for the corresponding Pong response.
+
+        Examples:
+            Send a Ping and wait for the Pong
+
+                pong_callback = await ws.ping()
+                # Will block until the corresponding Pong is received.
+                await pong_callback.wait()
+        """
+        ping_id, callback = self._ping_manager.create(payload)
+        event = wsproto.events.Ping(ping_id)
+        await self.send(event)
+        return callback
+
+    async def send(self, event: wsproto.events.Event) -> None:
+        """
+        Send an Event message.
+
+        Mainly useful to send events that are not supported by the library.
+        Most of the time, [ping()][httpx_ws.AsyncWebSocketSession.ping],
+        [send_text()][httpx_ws.AsyncWebSocketSession.send_text],
+        [send_bytes()][httpx_ws.AsyncWebSocketSession.send_bytes]
+        and [send_json()][httpx_ws.AsyncWebSocketSession.send_json] are preferred.
+
+        Args:
+            event: The event to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Send an event.
+
+                event = await wsproto.events.Message(b"Hello!")
+                ws.send(event)
+        """
+        import httpcore2
+
+        try:
+            data = self.connection.send(event)
+            async with self._write_lock:
+                await self.stream.write(data)
+        except httpcore2.WriteError as e:
+            await self.close(CloseReason.INTERNAL_ERROR, "Stream write error")
+            raise WebSocketNetworkError() from e
+
+    async def send_text(self, data: str) -> None:
+        """
+        Send a text message.
+
+        Args:
+            data: The text to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Send a text message.
+
+                await ws.send_text("Hello!")
+        """
+        event = wsproto.events.TextMessage(data=data)
+        await self.send(event)
+
+    async def send_bytes(self, data: bytes) -> None:
+        """
+        Send a bytes message.
+
+        Args:
+            data: The data to send.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Send a bytes message.
+
+                await ws.send_bytes(b"Hello!")
+        """
+        event = wsproto.events.BytesMessage(data=data)
+        await self.send(event)
+
+    async def send_json(self, data: typing.Any, mode: JSONMode = "text") -> None:
+        """
+        Send JSON data.
+
+        Args:
+            data:
+                The data to send. Must be serializable by [json.dumps][json.dumps].
+            mode:
+                The sending mode. Should either be `'text'` or `'bytes'`.
+
+        Raises:
+            WebSocketNetworkError: A network error occured.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Send JSON data.
+
+                data = {"message": "Hello!"}
+                await ws.send_json(data)
+        """
+        assert mode in ["text", "binary"]
+        serialized_data = json.dumps(data)
+        if mode == "text":
+            await self.send_text(serialized_data)
+        else:
+            await self.send_bytes(serialized_data.encode("utf-8"))
+
+    async def receive(self, timeout: float | None = None) -> wsproto.events.Event:
+        """
+        Receive an event from the server.
+
+        Mainly useful to receive raw [wsproto.events.Event][wsproto.events.Event].
+        Most of the time, [receive_text()][httpx_ws.AsyncWebSocketSession.receive_text],
+        [receive_bytes()][httpx_ws.AsyncWebSocketSession.receive_bytes],
+        and [receive_json()][httpx_ws.AsyncWebSocketSession.receive_json] are preferred.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            A raw [wsproto.events.Event][wsproto.events.Event].
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Wait for an event until one is available.
+
+                try:
+                    event = await ws.receive()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for an event for 2 seconds.
+
+                try:
+                    event = await ws.receive(timeout=2.)
+                except TimeoutError:
+                    print("No event received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        with anyio.fail_after(timeout):
+            event = await self._receive_event.receive()
+        if isinstance(event, HTTPXWSException):
+            raise event
+        if isinstance(event, wsproto.events.CloseConnection):
+            raise WebSocketDisconnect(event.code, event.reason)
+        return event
+
+    async def receive_text(self, timeout: float | None = None) -> str:
+        """
+        Receive text from the server.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            Text data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event was not a text message.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Wait for text until available.
+
+                try:
+                    text = await ws.receive_text()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for text for 2 seconds.
+
+                try:
+                    event = await ws.receive_text(timeout=2.)
+                except TimeoutError:
+                    print("No text received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        event = await self.receive(timeout)
+        if isinstance(event, wsproto.events.TextMessage):
+            return event.data
+        raise WebSocketInvalidTypeReceived(event)
+
+    async def receive_bytes(self, timeout: float | None = None) -> bytes:
+        """
+        Receive bytes from the server.
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+
+        Returns:
+            Bytes data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event was not a bytes message.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Wait for bytes until available.
+
+                try:
+                    data = await ws.receive_bytes()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for bytes for 2 seconds.
+
+                try:
+                    data = await ws.receive_bytes(timeout=2.)
+                except TimeoutError:
+                    print("No data received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        event = await self.receive(timeout)
+        if isinstance(event, wsproto.events.BytesMessage):
+            return bytes(event.data)
+        raise WebSocketInvalidTypeReceived(event)
+
+    async def receive_json(self, timeout: float | None = None, mode: JSONMode = "text") -> typing.Any:
+        """
+        Receive JSON data from the server.
+
+        The received data should be parseable by [json.loads][json.loads].
+
+        Args:
+            timeout:
+                Number of seconds to wait for an event.
+                If `None`, will block until an event is available.
+            mode:
+                Receive mode. Should either be `'text'` or `'bytes'`.
+
+        Returns:
+            Parsed JSON data.
+
+        Raises:
+            TimeoutError: No event was received before the timeout delay.
+            WebSocketDisconnect: The server closed the websocket.
+            WebSocketNetworkError: A network error occured.
+            WebSocketInvalidTypeReceived: The received event
+                didn't correspond to the specified mode.
+
+        Note:
+            Exceptions not caught inside the context manager will be
+            wrapped in an [ExceptionGroup][ExceptionGroup]. Use `except*` to catch them
+            outside the `async with` block.
+
+        Examples:
+            Wait for data until available.
+
+                try:
+                    data = await ws.receive_json()
+                except WebSocketDisconnect:
+                    print("Connection closed")
+
+            Wait for data for 2 seconds.
+
+                try:
+                    data = await ws.receive_json(timeout=2.)
+                except TimeoutError:
+                    print("No data received.")
+                except WebSocketDisconnect:
+                    print("Connection closed")
+        """
+        assert mode in ["text", "binary"]
+        data: str | bytes
+        if mode == "text":
+            data = await self.receive_text(timeout)
+        elif mode == "binary":
+            data = await self.receive_bytes(timeout)
+        return json.loads(data)
+
+    async def close(self, code: int = 1000, reason: str | None = None) -> None:
+        """
+        Close the WebSocket session.
+
+        Internally, it'll send the
+        [CloseConnection][wsproto.events.CloseConnection] event.
+
+        *This method is automatically called when exiting the context manager.*
+
+        Args:
+            code:
+                The integer close code to indicate why the connection has closed.
+            reason:
+                Additional reasoning for why the connection has closed.
+
+        Examples:
+            Close the WebSocket session.
+
+                await ws.close()
+        """
+        import httpcore2
+
+        self._should_close.set()
+        if self.connection.state not in {
+            wsproto.connection.ConnectionState.LOCAL_CLOSING,
+            wsproto.connection.ConnectionState.CLOSED,
+        }:
+            event = wsproto.events.CloseConnection(code, reason)
+            data = self.connection.send(event)
+            try:
+                async with self._write_lock:
+                    await self.stream.write(data)
+            except httpcore2.WriteError:
+                pass
+        await self.stream.aclose()
+
+    async def _background_receive(self, max_bytes: int) -> None:
+        """
+        Background task listening for data from the server.
+
+        Internally, it'll:
+
+        * Answer to Ping events.
+        * Acknowledge Pong events.
+        * Put other events in the [_events][_events]
+        queue that'll eventually be consumed by the user.
+
+        Args:
+            max_bytes: The maximum chunk size to read at each iteration.
+        """
+        import httpcore2
+
+        partial_message_buffer: str | bytes | None = None
+        partial_message_size = 0
+        try:
+            while not self._should_close.is_set():
+                data = await self._read_stream(max_bytes)
+                self.connection.receive_data(data)
+                for event in self.connection.events():
+                    if isinstance(event, wsproto.events.Ping):
+                        data = self.connection.send(event.response())
+                        async with self._write_lock:
+                            await self.stream.write(data)
+                        continue
+                    if isinstance(event, wsproto.events.Pong):
+                        self._ping_manager.ack(event.payload)
+                        continue
+                    if isinstance(event, wsproto.events.CloseConnection):
+                        self._should_close.set()
+                    if isinstance(event, wsproto.events.Message):
+                        partial_message_size += len(event.data.encode() if isinstance(event.data, str) else event.data)
+                        if partial_message_size > max_bytes:
+                            await self.close(CloseReason.MESSAGE_TOO_BIG, "Message too big")
+                            await self._send_event.send(
+                                WebSocketDisconnect(CloseReason.MESSAGE_TOO_BIG, "Message too big")
+                            )
+                            break
+                        # Unfinished message: bufferize
+                        if not event.message_finished:
+                            if partial_message_buffer is None:
+                                partial_message_buffer = event.data
+                            else:
+                                partial_message_buffer += event.data
+                        # Finished message but no buffer: just emit the event
+                        elif partial_message_buffer is None:
+                            partial_message_size = 0
+                            await self._send_event.send(event)
+                        # Finished message with buffer: emit the full event
+                        else:
+                            event_type = type(event)
+                            full_message_event = event_type(partial_message_buffer + event.data)
+                            partial_message_buffer = None
+                            partial_message_size = 0
+                            await self._send_event.send(full_message_event)
+                        continue
+                    await self._send_event.send(event)
+        except (httpcore2.ReadError, httpcore2.WriteError, EndOfStream):
+            await self.close(CloseReason.INTERNAL_ERROR, "Stream error")
+            await self._send_event.send(WebSocketNetworkError())
+
+    async def _background_keepalive_ping(self, interval_seconds: float, timeout_seconds: float | None = None) -> None:
+        while not self._should_close.is_set():
+            await anyio.sleep(interval_seconds)
+
+            try:
+                pong_callback = await self.ping()
+            # Connection is closing, exit the task
+            except wsproto.utilities.LocalProtocolError:
+                return
+
+            if timeout_seconds is not None:
+                try:
+                    with anyio.fail_after(timeout_seconds):
+                        await pong_callback.wait()
+                except TimeoutError:
+                    await self.close(CloseReason.INTERNAL_ERROR, "Keepalive ping timeout")
+                    await self._send_event.send(WebSocketNetworkError())
+
+    async def _read_stream(self, max_bytes: int) -> bytes:
+        data = await self.stream.read(max_bytes)
+        if data == b"":
+            raise EndOfStream()
+        return data
+
+
+def _get_headers(
+    subprotocols: list[str] | None,
+) -> dict[str, typing.Any]:
+    headers = {
+        "connection": "upgrade",
+        "upgrade": "websocket",
+        "sec-websocket-key": base64.b64encode(secrets.token_bytes(16)).decode("utf-8"),
+        "sec-websocket-version": "13",
+    }
+    if subprotocols is not None:
+        headers["sec-websocket-protocol"] = ", ".join(subprotocols)
+    return headers
+
+
+class WebSocketClient(typing.Generic[SyncSession]):
+    """
+    A sync WebSocket client.
+
+    This class provides an API for connecting to WebSocket.
+
+    Attributes:
+        client:
+            HTTPX client to use.
+        max_message_size_bytes:
+            Maximum incoming message size in bytes.
+            Larger messages, including fragmented messages whose
+            cumulative size exceeds the limit, close the connection
+            with `MESSAGE_TOO_BIG`.
+            Defaults to 65 KiB.
+        queue_size:
+            Size of the queue where the received messages will be held
+            until they are consumed.
+            If the queue is full, the client will stop receive messages
+            from the server until the queue has room available.
+            Defaults to 512.
+        keepalive_ping_interval_seconds:
+            Interval at which the client will automatically send a Ping event
+            to keep the connection alive. Set it to `None` to disable this mechanism.
+            Defaults to 20 seconds.
+        keepalive_ping_timeout_seconds:
+            Maximum delay the client will wait for an answer to its Ping event.
+            If the delay is exceeded,
+            [WebSocketNetworkError][httpx_ws.WebSocketNetworkError]
+            will be raised and the connection closed.
+            Defaults to 20 seconds.
+        session_class:
+            The session class to use.
+            Defaults to [WebSocketSession][httpx_ws.WebSocketSession].
+    """
+
+    def __init__(
+        self,
+        client: Client,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        session_class: type[SyncSession] = WebSocketSession,  # type: ignore[assignment]
+    ) -> None:
+        self.client = client
+        self.max_message_size_bytes = max_message_size_bytes
+        self.queue_size = queue_size
+        self.keepalive_ping_interval_seconds = keepalive_ping_interval_seconds
+        self.keepalive_ping_timeout_seconds = keepalive_ping_timeout_seconds
+        self.session_class = session_class
+
+    @contextlib.contextmanager
+    def connect(
+        self,
+        url: str,
+        *,
+        subprotocols: list[str] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> typing.Generator[SyncSession, None, None]:
+        """
+        Start a sync WebSocket session.
+
+        It returns a context manager that'll automatically
+        call [close()][httpx_ws.WebSocketSession.close] when exiting.
+
+        Args:
+            url: The WebSocket URL.
+            subprotocols:
+                Optional list of subprotocols to negotiate with the server.
+            params:
+                Query parameters to include in the handshake request.
+            headers:
+                Headers to include in the handshake request.
+            cookies:
+                Cookies to include in the handshake request.
+            auth:
+                Authentication to use for the handshake request.
+            follow_redirects:
+                Whether to follow redirects on the handshake request.
+            timeout:
+                Timeout configuration for the handshake request.
+            extensions:
+                Request extensions for the handshake request.
+
+        Returns:
+            A [context manager][contextlib.AbstractContextManager]
+                for [WebSocketSession][httpx_ws.WebSocketSession].
+
+        Examples:
+            Initialize the client and connect to a WebSocket.
+
+                with httpx2.Client() as client:
+                    ws_client = WebSocketClient(client)
+                    with ws_client.connect("http://localhost:8000/ws") as ws:
+                        message = ws.receive_text()
+                        print(message)
+                        ws.send_text("Hello!")
+        """
+        with self.client.stream(
+            "GET",
+            url,
+            params=params,
+            headers=Headers(headers) | _get_headers(subprotocols),
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as response:
+            if response.status_code != 101:
+                raise WebSocketUpgradeError(response)
+
+            session = self.session_class(
+                response.extensions["network_stream"],
+                max_message_size_bytes=self.max_message_size_bytes,
+                queue_size=self.queue_size,
+                keepalive_ping_interval_seconds=self.keepalive_ping_interval_seconds,
+                keepalive_ping_timeout_seconds=self.keepalive_ping_timeout_seconds,
+                response=response,
+            )
+            with session:
+                yield session
+
+
+@contextlib.contextmanager
+def connect_ws(
+    url: str,
+    client: Client | None = None,
+    *,
+    max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    queue_size: int = DEFAULT_QUEUE_SIZE,
+    keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+    subprotocols: list[str] | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+    extensions: RequestExtensions | None = None,
+) -> typing.Generator[WebSocketSession, None, None]:
+    """
+    Start a sync WebSocket session.
+
+    It returns a context manager that'll automatically
+    call [close()][httpx_ws.WebSocketSession.close] when exiting.
+
+    Args:
+        url: The WebSocket URL.
+        client:
+            HTTPX client to use.
+            If not provided, a default one will be initialized.
+        max_message_size_bytes:
+            Maximum incoming message size in bytes.
+            Larger messages, including fragmented messages whose
+            cumulative size exceeds the limit, close the connection
+            with `MESSAGE_TOO_BIG`.
+            Defaults to 65 KiB.
+        queue_size:
+            Size of the queue where the received messages will be held
+            until they are consumed.
+            If the queue is full, the client will stop receive messages
+            from the server until the queue has room available.
+            Defaults to 512.
+        keepalive_ping_interval_seconds:
+            Interval at which the client will automatically send a Ping event
+            to keep the connection alive. Set it to `None` to disable this mechanism.
+            Defaults to 20 seconds.
+        keepalive_ping_timeout_seconds:
+            Maximum delay the client will wait for an answer to its Ping event.
+            If the delay is exceeded,
+            [WebSocketNetworkError][httpx_ws.WebSocketNetworkError]
+            will be raised and the connection closed.
+            Defaults to 20 seconds.
+        subprotocols:
+            Optional list of subprotocols to negotiate with the server.
+        params:
+            Query parameters to include in the handshake request.
+        headers:
+            Headers to include in the handshake request.
+        cookies:
+            Cookies to include in the handshake request.
+        auth:
+            Authentication to use for the handshake request.
+        follow_redirects:
+            Whether to follow redirects on the handshake request.
+        timeout:
+            Timeout configuration for the handshake request.
+        extensions:
+            Request extensions for the handshake request.
+
+    Returns:
+        A [context manager][contextlib.AbstractContextManager]
+            for [WebSocketSession][httpx_ws.WebSocketSession].
+
+    Examples:
+        Without explicit HTTPX client.
+
+            with connect_ws("http://localhost:8000/ws") as ws:
+                message = ws.receive_text()
+                print(message)
+                ws.send_text("Hello!")
+
+        With explicit HTTPX client.
+
+            with httpx2.Client() as client:
+                with connect_ws("http://localhost:8000/ws", client) as ws:
+                    message = ws.receive_text()
+                    print(message)
+                    ws.send_text("Hello!")
+    """
+    if client is None:
+        from .._client import Client
+
+        owned_client: contextlib.AbstractContextManager[Client] = Client()
+    else:
+        owned_client = contextlib.nullcontext(client)
+
+    with owned_client as client:
+        ws_client = WebSocketClient(
+            client=client,
+            max_message_size_bytes=max_message_size_bytes,
+            queue_size=queue_size,
+            keepalive_ping_interval_seconds=keepalive_ping_interval_seconds,
+            keepalive_ping_timeout_seconds=keepalive_ping_timeout_seconds,
+        )
+        with ws_client.connect(
+            url,
+            subprotocols=subprotocols,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as websocket:
+            yield websocket
+
+
+class AsyncWebSocketClient(typing.Generic[AsyncSession]):
+    """
+    An async WebSocket client.
+
+    This class provides an API for connecting to WebSocket.
+
+    Attributes:
+        client:
+            HTTPX client to use.
+        max_message_size_bytes:
+            Maximum incoming message size in bytes.
+            Larger messages, including fragmented messages whose
+            cumulative size exceeds the limit, close the connection
+            with `MESSAGE_TOO_BIG`.
+            Defaults to 65 KiB.
+        queue_size:
+            Size of the queue where the received messages will be held
+            until they are consumed.
+            If the queue is full, the client will stop receive messages
+            from the server until the queue has room available.
+            Defaults to 512.
+        keepalive_ping_interval_seconds:
+            Interval at which the client will automatically send a Ping event
+            to keep the connection alive. Set it to `None` to disable this mechanism.
+            Defaults to 20 seconds.
+        keepalive_ping_timeout_seconds:
+            Maximum delay the client will wait for an answer to its Ping event.
+            If the delay is exceeded,
+            [WebSocketNetworkError][httpx_ws.WebSocketNetworkError]
+            will be raised in an [ExceptionGroup][ExceptionGroup] and the connection closed.
+            Defaults to 20 seconds.
+        session_class:
+            The session class to use.
+            Defaults to [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession].
+    """
+
+    def __init__(
+        self,
+        client: AsyncClient,
+        *,
+        max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+        queue_size: int = DEFAULT_QUEUE_SIZE,
+        keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+        keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+        session_class: type[AsyncSession] = AsyncWebSocketSession,  # type: ignore[assignment]
+    ) -> None:
+        self.client = client
+        self.max_message_size_bytes = max_message_size_bytes
+        self.queue_size = queue_size
+        self.keepalive_ping_interval_seconds = keepalive_ping_interval_seconds
+        self.keepalive_ping_timeout_seconds = keepalive_ping_timeout_seconds
+        self.session_class = session_class
+
+    @contextlib.asynccontextmanager
+    async def connect(
+        self,
+        url: str,
+        *,
+        subprotocols: list[str] | None = None,
+        params: QueryParamTypes | None = None,
+        headers: HeaderTypes | None = None,
+        cookies: CookieTypes | None = None,
+        auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+        follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+        timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+        extensions: RequestExtensions | None = None,
+    ) -> typing.AsyncGenerator[AsyncSession, None]:
+        """
+        Start an async WebSocket session.
+
+        It returns an async context manager that'll automatically
+        call [close()][httpx_ws.AsyncWebSocketSession.close] when exiting.
+
+        Args:
+            url: The WebSocket URL.
+            subprotocols:
+                Optional list of subprotocols to negotiate with the server.
+            params:
+                Query parameters to include in the handshake request.
+            headers:
+                Headers to include in the handshake request.
+            cookies:
+                Cookies to include in the handshake request.
+            auth:
+                Authentication to use for the handshake request.
+            follow_redirects:
+                Whether to follow redirects on the handshake request.
+            timeout:
+                Timeout configuration for the handshake request.
+            extensions:
+                Request extensions for the handshake request.
+
+        Returns:
+            An [async context manager][contextlib.AbstractAsyncContextManager]
+                for [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession].
+
+        Examples:
+            Initialize the client and connect to a WebSocket.
+
+                async with httpx2.AsyncClient() as client:
+                    ws_client = AsyncWebSocketClient(client)
+                    async with ws_client.connect("http://localhost:8000/ws") as ws:
+                        message = await ws.receive_text()
+                        print(message)
+                        await ws.send_text("Hello!")
+        """
+        async with self.client.stream(
+            "GET",
+            url,
+            params=params,
+            headers=Headers(headers) | _get_headers(subprotocols),
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as response:
+            if response.status_code != 101:
+                raise WebSocketUpgradeError(response)
+
+            session = self.session_class(
+                response.extensions["network_stream"],
+                max_message_size_bytes=self.max_message_size_bytes,
+                queue_size=self.queue_size,
+                keepalive_ping_interval_seconds=self.keepalive_ping_interval_seconds,
+                keepalive_ping_timeout_seconds=self.keepalive_ping_timeout_seconds,
+                response=response,
+            )
+            async with session:
+                yield session
+
+
+@contextlib.asynccontextmanager
+async def aconnect_ws(
+    url: str,
+    client: AsyncClient | None = None,
+    *,
+    max_message_size_bytes: int = DEFAULT_MAX_MESSAGE_SIZE_BYTES,
+    queue_size: int = DEFAULT_QUEUE_SIZE,
+    keepalive_ping_interval_seconds: float | None = DEFAULT_KEEPALIVE_PING_INTERVAL_SECONDS,
+    keepalive_ping_timeout_seconds: float | None = DEFAULT_KEEPALIVE_PING_TIMEOUT_SECONDS,
+    subprotocols: list[str] | None = None,
+    params: QueryParamTypes | None = None,
+    headers: HeaderTypes | None = None,
+    cookies: CookieTypes | None = None,
+    auth: AuthTypes | UseClientDefault | None = USE_CLIENT_DEFAULT,
+    follow_redirects: bool | UseClientDefault = USE_CLIENT_DEFAULT,
+    timeout: TimeoutTypes | UseClientDefault = USE_CLIENT_DEFAULT,
+    extensions: RequestExtensions | None = None,
+) -> typing.AsyncGenerator[AsyncWebSocketSession, None]:
+    """
+    Start an async WebSocket session.
+
+    It returns an async context manager that'll automatically
+    call [close()][httpx_ws.AsyncWebSocketSession.close] when exiting.
+
+    Args:
+        url: The WebSocket URL.
+        client:
+            HTTPX client to use.
+            If not provided, a default one will be initialized.
+        max_message_size_bytes:
+            Maximum incoming message size in bytes.
+            Larger messages, including fragmented messages whose
+            cumulative size exceeds the limit, close the connection
+            with `MESSAGE_TOO_BIG`.
+            Defaults to 65 KiB.
+        queue_size:
+            Size of the queue where the received messages will be held
+            until they are consumed.
+            If the queue is full, the client will stop receive messages
+            from the server until the queue has room available.
+            Defaults to 512.
+        keepalive_ping_interval_seconds:
+            Interval at which the client will automatically send a Ping event
+            to keep the connection alive. Set it to `None` to disable this mechanism.
+            Defaults to 20 seconds.
+        keepalive_ping_timeout_seconds:
+            Maximum delay the client will wait for an answer to its Ping event.
+            If the delay is exceeded,
+            [WebSocketNetworkError][httpx_ws.WebSocketNetworkError]
+            will be raised in an [ExceptionGroup][ExceptionGroup] and the connection closed.
+            Defaults to 20 seconds.
+        subprotocols:
+            Optional list of subprotocols to negotiate with the server.
+        params:
+            Query parameters to include in the handshake request.
+        headers:
+            Headers to include in the handshake request.
+        cookies:
+            Cookies to include in the handshake request.
+        auth:
+            Authentication to use for the handshake request.
+        follow_redirects:
+            Whether to follow redirects on the handshake request.
+        timeout:
+            Timeout configuration for the handshake request.
+        extensions:
+            Request extensions for the handshake request.
+
+    Returns:
+        An [async context manager][contextlib.AbstractAsyncContextManager]
+            for [AsyncWebSocketSession][httpx_ws.AsyncWebSocketSession].
+
+    Examples:
+        Without explicit HTTPX client.
+
+            async with aconnect_ws("http://localhost:8000/ws") as ws:
+                message = await ws.receive_text()
+                print(message)
+                await ws.send_text("Hello!")
+
+        With explicit HTTPX client.
+
+            async with httpx2.AsyncClient() as client:
+                async with aconnect_ws("http://localhost:8000/ws", client) as ws:
+                    message = await ws.receive_text()
+                    print(message)
+                    await ws.send_text("Hello!")
+    """
+    if client is None:
+        from .._client import AsyncClient
+
+        owned_client: contextlib.AbstractAsyncContextManager[AsyncClient] = AsyncClient()
+    else:
+        owned_client = contextlib.nullcontext(client)
+
+    async with owned_client as client:
+        ws_client = AsyncWebSocketClient(
+            client=client,
+            max_message_size_bytes=max_message_size_bytes,
+            queue_size=queue_size,
+            keepalive_ping_interval_seconds=keepalive_ping_interval_seconds,
+            keepalive_ping_timeout_seconds=keepalive_ping_timeout_seconds,
+        )
+        async with ws_client.connect(
+            url,
+            subprotocols=subprotocols,
+            params=params,
+            headers=headers,
+            cookies=cookies,
+            auth=auth,
+            follow_redirects=follow_redirects,
+            timeout=timeout,
+            extensions=extensions,
+        ) as websocket:
+            yield websocket
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_exceptions.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_exceptions.py
new file mode 100644
index 0000000000000000000000000000000000000000..df3a50000ca94be9509dca822d6945aab9331305
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_exceptions.py
@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import typing
+
+if typing.TYPE_CHECKING:
+    import wsproto
+
+    from .._models import Response
+
+
+class HTTPXWSException(Exception):
+    """
+    Base exception class for HTTPX WS.
+    """
+
+
+class WebSocketUpgradeError(HTTPXWSException):
+    """
+    Raised when the initial connection didn't correctly upgrade to a WebSocket session.
+    """
+
+    def __init__(self, response: Response) -> None:
+        self.response = response
+
+
+class WebSocketDisconnect(HTTPXWSException):
+    """
+    Raised when the server closed the WebSocket session.
+
+    Args:
+        code:
+            The integer close code to indicate why the connection has closed.
+        reason:
+            Additional reasoning for why the connection has closed.
+    """
+
+    def __init__(self, code: int = 1000, reason: str | None = None) -> None:
+        self.code = code
+        self.reason = reason or ""
+
+
+class WebSocketInvalidTypeReceived(HTTPXWSException):
+    """
+    Raised when an event is not of the expected type.
+    """
+
+    def __init__(self, event: wsproto.events.Event) -> None:
+        self.event = event
+
+
+class WebSocketNetworkError(HTTPXWSException):
+    """
+    Raised when a network error occured,
+    typically if the underlying stream has closed or timeout.
+    """
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_ping.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_ping.py
new file mode 100644
index 0000000000000000000000000000000000000000..73aff9cdf41912a7351cc0b0081d546c5a0f03f7
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_ping.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import secrets
+import threading
+
+import anyio
+
+
+class PingManagerBase:
+    def _generate_id(self) -> bytes:
+        return secrets.token_bytes()
+
+
+class PingManager(PingManagerBase):
+    def __init__(self) -> None:
+        self._pings: dict[bytes, threading.Event] = {}
+
+    def create(self, ping_id: bytes | None = None) -> tuple[bytes, threading.Event]:
+        ping_id = self._generate_id() if not ping_id else ping_id
+        event = threading.Event()
+        self._pings[ping_id] = event
+        return ping_id, event
+
+    def ack(self, ping_id: bytes | bytearray) -> None:
+        event = self._pings.pop(bytes(ping_id), None)
+        if event is not None:
+            event.set()
+
+
+class AsyncPingManager(PingManagerBase):
+    def __init__(self) -> None:
+        self._pings: dict[bytes, anyio.Event] = {}
+
+    def create(self, ping_id: bytes | None = None) -> tuple[bytes, anyio.Event]:
+        ping_id = self._generate_id() if not ping_id else ping_id
+        event = anyio.Event()
+        self._pings[ping_id] = event
+        return ping_id, event
+
+    def ack(self, ping_id: bytes | bytearray) -> None:
+        event = self._pings.pop(bytes(ping_id), None)
+        if event is not None:
+            event.set()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_transport.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_transport.py
new file mode 100644
index 0000000000000000000000000000000000000000..6048447955400ddaed7fb4403a1e74e522c37a5f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/httpx2/websockets/_transport.py
@@ -0,0 +1,289 @@
+from __future__ import annotations
+
+import contextlib
+import math
+import typing
+from types import TracebackType
+
+import anyio
+import wsproto
+from anyio.streams.stapled import StapledObjectStream
+from wsproto.frame_protocol import CloseReason
+
+from .._models import Request, Response
+from .._transports.asgi import ASGITransport, _ASGIApp
+from .._types import AsyncByteStream
+from ._exceptions import WebSocketDisconnect, WebSocketUpgradeError
+
+Scope = dict[str, typing.Any]
+Message = dict[str, typing.Any]
+Receive = typing.Callable[[], typing.Awaitable[Message]]
+Send = typing.Callable[[Scope], typing.Coroutine[None, None, None]]
+ASGIApp = typing.Callable[[Scope, Receive, Send], typing.Coroutine[None, None, None]]
+
+
+class ASGIWebSocketTransportError(Exception):
+    pass
+
+
+class UnhandledASGIMessageType(ASGIWebSocketTransportError):
+    def __init__(self, message: Message) -> None:
+        self.message = message
+
+
+class UnhandledWebSocketEvent(ASGIWebSocketTransportError):
+    def __init__(self, event: wsproto.events.Event) -> None:
+        self.event = event
+
+
+class ASGIWebSocketAsyncNetworkStream:
+    def __init__(
+        self,
+        app: ASGIApp,
+        scope: Scope,
+        task_group: anyio.abc.TaskGroup,
+        initial_receive_timeout: float = 1.0,
+    ) -> None:
+        self.app = app
+        self.scope = scope
+        self._receive_queue = StapledObjectStream(*anyio.create_memory_object_stream[Message](max_buffer_size=math.inf))
+        self._send_queue = StapledObjectStream(*anyio.create_memory_object_stream[Message](max_buffer_size=math.inf))
+        self._task_group = task_group
+        self._initial_receive_timeout = initial_receive_timeout
+        self.connection = wsproto.WSConnection(wsproto.ConnectionType.SERVER)
+        self.connection.initiate_upgrade_connection(scope["headers"], scope["path"])
+        self._aentered = False
+
+    async def __aenter__(
+        self,
+    ) -> tuple[ASGIWebSocketAsyncNetworkStream, bytes]:
+        if self._aentered:
+            raise RuntimeError("Cannot use ASGIWebSocketAsyncNetworkStream in a context manager twice")
+        self._aentered = True
+        self._task_group.start_soon(self._run)
+        async with contextlib.AsyncExitStack() as stack:
+            stack.push_async_callback(self.aclose)
+            await self.send({"type": "websocket.connect"})
+
+            try:
+                message = await self.receive(self._initial_receive_timeout)
+            except TimeoutError as e:
+                raise RuntimeError(
+                    "WebSocket didn't accept the connection in time. Did you forget to call accept()?"
+                ) from e
+
+            if message["type"] == "websocket.close":
+                await stack.aclose()
+                raise WebSocketDisconnect(message["code"], message.get("reason"))
+
+            # Websocket Denial Response extension
+            # Ref: https://asgi.readthedocs.io/en/latest/extensions.html#websocket-denial-response
+            if message["type"] == "websocket.http.response.start":
+                status_code: int = message["status"]
+                headers: list[tuple[bytes, bytes]] = message["headers"]
+                body: list[bytes] = []
+                while True:
+                    message = await self.receive()
+                    assert message["type"] == "websocket.http.response.body"
+                    body.append(message["body"])
+                    if not message.get("more_body", False):
+                        break
+
+                await stack.aclose()
+                raise WebSocketUpgradeError(Response(status_code, headers=headers, content=b"".join(body)))
+
+            assert message["type"] == "websocket.accept"
+            retval = self, self._build_accept_response(message)
+            self._exit_stack = stack.pop_all()
+        return retval
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> bool | None:
+        return await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def read(self, max_bytes: int, timeout: float | None = None) -> bytes:
+        import httpcore2
+
+        try:
+            message: Message = await self.receive(timeout=timeout)
+        except anyio.EndOfStream:
+            return b""
+        except anyio.ClosedResourceError as exc:
+            raise httpcore2.ReadError() from exc
+        type = message["type"]
+
+        if type not in {"websocket.send", "websocket.close"}:
+            raise UnhandledASGIMessageType(message)
+
+        event: wsproto.events.Event
+        if type == "websocket.send":
+            data_str: str | None = message.get("text")
+            if data_str is not None:
+                event = wsproto.events.TextMessage(data_str)
+            data_bytes: bytes | None = message.get("bytes")
+            if data_bytes is not None:
+                event = wsproto.events.BytesMessage(data_bytes)
+        elif type == "websocket.close":
+            event = wsproto.events.CloseConnection(message["code"], message["reason"])
+
+        return self.connection.send(event)
+
+    async def write(self, buffer: bytes, timeout: float | None = None) -> None:
+        self.connection.receive_data(buffer)
+        for event in self.connection.events():
+            if isinstance(event, wsproto.events.Request):
+                pass
+            elif isinstance(event, wsproto.events.CloseConnection):
+                await self.send(
+                    {
+                        "type": "websocket.disconnect",
+                        "code": event.code,
+                        "reason": event.reason,
+                    }
+                )
+            elif isinstance(event, wsproto.events.TextMessage):
+                await self.send({"type": "websocket.receive", "text": event.data})
+            elif isinstance(event, wsproto.events.BytesMessage):
+                await self.send({"type": "websocket.receive", "bytes": event.data})
+            else:
+                raise UnhandledWebSocketEvent(event)
+
+    async def aclose(self) -> None:
+        with contextlib.suppress(anyio.ClosedResourceError):
+            await self.send({"type": "websocket.disconnect"})
+        await self._receive_queue.aclose()
+        await self._send_queue.aclose()
+
+    async def send(self, message: Message) -> None:
+        await self._receive_queue.send(message)
+
+    async def receive(self, timeout: float | None = None) -> Message:
+        if timeout is None:
+            timeout = math.inf
+        with anyio.fail_after(timeout):
+            return await self._send_queue.receive()
+
+    async def _run(self) -> None:
+        """
+        The sub-thread in which the websocket session runs.
+        """
+        scope = self.scope
+        receive = self._receive_queue.receive
+        send = self._send_queue.send
+        try:
+            await self.app(scope, receive, send)
+        except Exception as e:
+            message = {
+                "type": "websocket.close",
+                "code": CloseReason.INTERNAL_ERROR,
+                "reason": str(e),
+            }
+            with contextlib.suppress(anyio.ClosedResourceError):
+                await send(message)
+
+    def _build_accept_response(self, message: Message) -> bytes:
+        subprotocol = message.get("subprotocol", None)
+        headers = message.get("headers", [])
+        return self.connection.send(
+            wsproto.events.AcceptConnection(
+                subprotocol=subprotocol,
+                extra_headers=headers,
+            )
+        )
+
+
+class ASGIWebSocketTransport(ASGITransport):
+    def __init__(
+        self,
+        app: _ASGIApp,
+        raise_app_exceptions: bool = True,
+        root_path: str = "",
+        client: tuple[str, int] = ("127.0.0.1", 123),
+        initial_receive_timeout: float = 1.0,
+    ) -> None:
+        super().__init__(app, raise_app_exceptions, root_path, client)
+        self._exit_stack: contextlib.AsyncExitStack | None = None
+        self._initial_receive_timeout = initial_receive_timeout
+
+    async def __aenter__(self) -> ASGIWebSocketTransport:
+        async with contextlib.AsyncExitStack() as stack:
+            self._task_group = await stack.enter_async_context(anyio.create_task_group())
+            self._exit_stack = stack.pop_all()
+
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_val: BaseException | None = None,
+        exc_tb: TracebackType | None = None,
+    ) -> None:
+        await super().__aexit__(exc_type, exc_val, exc_tb)
+        assert self._exit_stack is not None
+        await self._exit_stack.__aexit__(exc_type, exc_val, exc_tb)
+
+    async def handle_async_request(self, request: Request) -> Response:
+        scheme = request.url.scheme
+        headers = request.headers
+
+        if scheme in {"ws", "wss"} or headers.get("upgrade") == "websocket":
+            subprotocols: list[str] = []
+            if (subprotocols_header := headers.get("sec-websocket-protocol")) is not None:
+                subprotocols = subprotocols_header.split(",")
+
+            scope = {
+                "type": "websocket",
+                "path": request.url.path,
+                "raw_path": request.url.raw_path,
+                "root_path": self.root_path,
+                "scheme": scheme,
+                "query_string": request.url.query,
+                "headers": [(k.lower(), v) for (k, v) in request.headers.raw],
+                "client": self.client,
+                "server": (request.url.host, request.url.port),
+                "subprotocols": subprotocols,
+            }
+            return await self._handle_ws_request(request, scope)
+
+        return await super().handle_async_request(request)
+
+    async def _create_asgi_websocket_async_network_stream(
+        self,
+        *,
+        task_status: anyio.abc.TaskStatus[tuple[ASGIWebSocketAsyncNetworkStream, bytes]],
+    ) -> None:
+        stream = ASGIWebSocketAsyncNetworkStream(
+            self.app,  # type: ignore[arg-type]
+            self.scope,
+            self._task_group,
+            self._initial_receive_timeout,
+        )
+        assert self._exit_stack is not None
+        result = await self._exit_stack.enter_async_context(stream)
+        task_status.started(result)
+
+    async def _handle_ws_request(
+        self,
+        request: Request,
+        scope: Scope,
+    ) -> Response:
+        assert isinstance(request.stream, AsyncByteStream)
+
+        self.scope = scope
+        stream, accept_response = await self._task_group.start(self._create_asgi_websocket_async_network_stream)
+        accept_response_lines = accept_response.decode("utf-8").splitlines()
+        headers = [
+            typing.cast(tuple[str, str], line.split(": ", 1))
+            for line in accept_response_lines[1:]
+            if line.strip() != ""
+        ]
+
+        return Response(
+            status_code=101,
+            headers=headers,
+            extensions={"network_stream": stream},
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..1ab6a0c28147517f8c617951bd974522be18595d
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__init__.py
@@ -0,0 +1,1840 @@
+# Copyright 2020 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.
+
+# ***********
+# `huggingface_hub` init has 2 modes:
+# - Normal usage:
+#       If imported to use it, all modules and functions are lazy-loaded. This means
+#       they exist at top level in module but are imported only the first time they are
+#       used. This way, `from huggingface_hub import something` will import `something`
+#       quickly without the hassle of importing all the features from `huggingface_hub`.
+# - Static check:
+#       If statically analyzed, all modules and functions are loaded normally. This way
+#       static typing check works properly as well as autocomplete in text editors and
+#       IDEs.
+#
+# The static model imports are done inside the `if TYPE_CHECKING:` statement at
+# the bottom of this file. Since module/functions imports are duplicated, it is
+# mandatory to make sure to add them twice when adding one. This is checked in the
+# `make quality` command.
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update-file
+#
+# # Or run style on codebase
+# make style
+# ```
+#
+# ***********
+# Lazy loader vendored from https://github.com/scientific-python/lazy_loader
+import importlib
+import os
+import sys
+from typing import TYPE_CHECKING
+
+
+__version__ = "2.2.0"
+
+# Alphabetical order of definitions is ensured in tests
+# WARNING: any comment added in this dictionary definition will be lost when
+# re-generating the file !
+_SUBMOD_ATTRS = {
+    "_buckets": [
+        "BucketFile",
+        "BucketFileMetadata",
+        "BucketFolder",
+        "BucketInfo",
+        "BucketUrl",
+        "SyncOperation",
+        "SyncPlan",
+    ],
+    "_commit_api": [
+        "CommitOperation",
+        "CommitOperationAdd",
+        "CommitOperationCopy",
+        "CommitOperationDelete",
+    ],
+    "_commit_scheduler": [
+        "CommitScheduler",
+    ],
+    "_eval_results": [
+        "EvalResultEntry",
+        "eval_result_entries_to_yaml",
+        "parse_eval_result_entries",
+    ],
+    "_inference_endpoints": [
+        "InferenceCatalogModel",
+        "InferenceCatalogRecipe",
+        "InferenceEndpoint",
+        "InferenceEndpointError",
+        "InferenceEndpointHardware",
+        "InferenceEndpointStatus",
+        "InferenceEndpointTimeoutError",
+        "InferenceEndpointType",
+    ],
+    "_jobs_api": [
+        "JobAccelerator",
+        "JobDurations",
+        "JobHardware",
+        "JobHardwareInfo",
+        "JobInfo",
+        "JobInitiator",
+        "JobNetwork",
+        "JobOwner",
+        "JobStage",
+        "JobStatus",
+    ],
+    "_login": [
+        "auth_list",
+        "auth_switch",
+        "interpreter_login",
+        "login",
+        "logout",
+        "notebook_login",
+    ],
+    "_oauth": [
+        "OAuthInfo",
+        "OAuthOrgInfo",
+        "OAuthUserInfo",
+        "attach_huggingface_oauth",
+        "parse_huggingface_oauth",
+    ],
+    "_revision": [
+        "ResolvedRevision",
+    ],
+    "_sandbox": [
+        "Sandbox",
+        "SandboxCommandResult",
+        "SandboxPool",
+        "SandboxProcess",
+    ],
+    "_snapshot_download": [
+        "get_cached_repo_tree",
+        "snapshot_download",
+    ],
+    "_space_api": [
+        "SpaceHardware",
+        "SpaceRuntime",
+        "SpaceSecret",
+        "SpaceStage",
+        "SpaceStorage",
+        "SpaceVariable",
+        "Volume",
+        "ZeroGpuQuota",
+    ],
+    "_tensorboard_logger": [
+        "HFSummaryWriter",
+    ],
+    "_webhooks_payload": [
+        "WebhookPayload",
+        "WebhookPayloadComment",
+        "WebhookPayloadDiscussion",
+        "WebhookPayloadDiscussionChanges",
+        "WebhookPayloadEvent",
+        "WebhookPayloadMovedTo",
+        "WebhookPayloadRepo",
+        "WebhookPayloadUrl",
+        "WebhookPayloadWebhook",
+    ],
+    "_webhooks_server": [
+        "WebhooksServer",
+        "webhook_endpoint",
+    ],
+    "cli._cli_utils": [
+        "check_cli_update",
+        "typer_factory",
+    ],
+    "community": [
+        "Discussion",
+        "DiscussionComment",
+        "DiscussionCommit",
+        "DiscussionEvent",
+        "DiscussionStatusChange",
+        "DiscussionTitleChange",
+        "DiscussionWithDetails",
+    ],
+    "constants": [
+        "CONFIG_NAME",
+        "FLAX_WEIGHTS_NAME",
+        "HUGGINGFACE_CO_URL_HOME",
+        "HUGGINGFACE_CO_URL_TEMPLATE",
+        "PYTORCH_WEIGHTS_NAME",
+        "REPO_TYPE_DATASET",
+        "REPO_TYPE_MODEL",
+        "REPO_TYPE_SPACE",
+        "TF2_WEIGHTS_NAME",
+        "TF_WEIGHTS_NAME",
+        "is_offline_mode",
+    ],
+    "fastai_utils": [
+        "_save_pretrained_fastai",
+        "from_pretrained_fastai",
+        "push_to_hub_fastai",
+    ],
+    "file_download": [
+        "DryRunFileInfo",
+        "HfFileMetadata",
+        "_CACHED_NO_EXIST",
+        "get_hf_file_metadata",
+        "hf_hub_download",
+        "hf_hub_url",
+        "try_to_load_from_cache",
+    ],
+    "hf_api": [
+        "Collection",
+        "CollectionItem",
+        "CommitInfo",
+        "DatasetInfo",
+        "DatasetLeaderboardEntry",
+        "DuplicatedRepoUrl",
+        "GitCommitInfo",
+        "GitRefInfo",
+        "GitRefs",
+        "HfApi",
+        "KernelInfo",
+        "ModelInfo",
+        "Organization",
+        "RepoFile",
+        "RepoFolder",
+        "RepoStorageInfo",
+        "RepoUrl",
+        "SpaceInfo",
+        "SpaceSearchResult",
+        "SpaceTemplate",
+        "User",
+        "UserLikes",
+        "WebhookInfo",
+        "WebhookWatchedItem",
+        "accept_access_request",
+        "add_collection_item",
+        "add_space_secret",
+        "add_space_variable",
+        "auth_check",
+        "batch_bucket_files",
+        "bucket_info",
+        "cancel_access_request",
+        "cancel_job",
+        "change_discussion_status",
+        "comment_discussion",
+        "copy_files",
+        "create_branch",
+        "create_bucket",
+        "create_collection",
+        "create_commit",
+        "create_discussion",
+        "create_inference_endpoint",
+        "create_inference_endpoint_from_catalog",
+        "create_pull_request",
+        "create_repo",
+        "create_scheduled_job",
+        "create_scheduled_uv_job",
+        "create_tag",
+        "create_webhook",
+        "dataset_info",
+        "delete_branch",
+        "delete_bucket",
+        "delete_collection",
+        "delete_collection_item",
+        "delete_file",
+        "delete_folder",
+        "delete_inference_endpoint",
+        "delete_repo",
+        "delete_scheduled_job",
+        "delete_space_secret",
+        "delete_space_variable",
+        "delete_space_volumes",
+        "delete_tag",
+        "delete_webhook",
+        "disable_space_dev_mode",
+        "disable_webhook",
+        "download_bucket_files",
+        "duplicate_repo",
+        "edit_discussion_comment",
+        "enable_space_dev_mode",
+        "enable_webhook",
+        "fetch_job_logs",
+        "fetch_job_metrics",
+        "fetch_space_logs",
+        "file_exists",
+        "get_bucket_file_metadata",
+        "get_bucket_paths_info",
+        "get_collection",
+        "get_dataset_leaderboard",
+        "get_dataset_tags",
+        "get_discussion_details",
+        "get_full_repo_name",
+        "get_inference_endpoint",
+        "get_local_safetensors_metadata",
+        "get_model_tags",
+        "get_organization_overview",
+        "get_paths_info",
+        "get_repo_discussions",
+        "get_safetensors_metadata",
+        "get_space_runtime",
+        "get_space_secrets",
+        "get_space_variables",
+        "get_user_overview",
+        "get_webhook",
+        "get_zero_gpu_quota",
+        "grant_access",
+        "inspect_job",
+        "inspect_scheduled_job",
+        "kernel_info",
+        "list_accepted_access_requests",
+        "list_bucket_tree",
+        "list_buckets",
+        "list_collections",
+        "list_daily_papers",
+        "list_dataset_parquet_files",
+        "list_datasets",
+        "list_inference_catalog",
+        "list_inference_endpoints",
+        "list_inference_endpoints_hardware",
+        "list_jobs",
+        "list_jobs_hardware",
+        "list_lfs_files",
+        "list_liked_repos",
+        "list_models",
+        "list_organization_followers",
+        "list_organization_members",
+        "list_papers",
+        "list_pending_access_requests",
+        "list_rejected_access_requests",
+        "list_repo_commits",
+        "list_repo_files",
+        "list_repo_likers",
+        "list_repo_refs",
+        "list_repo_tree",
+        "list_space_templates",
+        "list_spaces",
+        "list_spaces_hardware",
+        "list_user_followers",
+        "list_user_following",
+        "list_user_repos",
+        "list_webhooks",
+        "merge_pull_request",
+        "model_info",
+        "move_bucket",
+        "move_repo",
+        "paper_info",
+        "parse_local_safetensors_file_metadata",
+        "parse_safetensors_file_metadata",
+        "pause_inference_endpoint",
+        "pause_space",
+        "permanently_delete_lfs_files",
+        "preupload_lfs_files",
+        "read_paper",
+        "reject_access_request",
+        "rename_discussion",
+        "repo_exists",
+        "repo_info",
+        "request_space_hardware",
+        "rerun_job",
+        "resolve_revision",
+        "restart_space",
+        "resume_inference_endpoint",
+        "resume_scheduled_job",
+        "revision_exists",
+        "run_as_future",
+        "run_job",
+        "run_uv_job",
+        "scale_to_zero_inference_endpoint",
+        "search_spaces",
+        "set_space_sleep_time",
+        "set_space_volumes",
+        "space_info",
+        "super_squash_history",
+        "suspend_scheduled_job",
+        "sync_bucket",
+        "sync_job_volume",
+        "trigger_scheduled_job",
+        "unlike",
+        "update_bucket_settings",
+        "update_collection_item",
+        "update_collection_metadata",
+        "update_collection_resource_group",
+        "update_inference_endpoint",
+        "update_job_expose",
+        "update_job_labels",
+        "update_repo_settings",
+        "update_scheduled_job_labels",
+        "update_scheduled_job_schedule",
+        "update_webhook",
+        "upload_file",
+        "upload_folder",
+        "verify_repo_checksums",
+        "wait_for_job",
+        "wait_for_space",
+        "whoami",
+    ],
+    "hf_file_system": [
+        "HfFileSystem",
+        "HfFileSystemFile",
+        "HfFileSystemResolvedPath",
+        "HfFileSystemStreamFile",
+        "hffs",
+    ],
+    "hub_mixin": [
+        "ModelHubMixin",
+        "PyTorchModelHubMixin",
+    ],
+    "inference._client": [
+        "InferenceClient",
+        "InferenceTimeoutError",
+    ],
+    "inference._generated._async_client": [
+        "AsyncInferenceClient",
+    ],
+    "inference._generated.types": [
+        "AudioClassificationInput",
+        "AudioClassificationOutputElement",
+        "AudioClassificationOutputTransform",
+        "AudioClassificationParameters",
+        "AudioToAudioInput",
+        "AudioToAudioOutputElement",
+        "AutomaticSpeechRecognitionEarlyStoppingEnum",
+        "AutomaticSpeechRecognitionGenerationParameters",
+        "AutomaticSpeechRecognitionInput",
+        "AutomaticSpeechRecognitionOutput",
+        "AutomaticSpeechRecognitionOutputChunk",
+        "AutomaticSpeechRecognitionParameters",
+        "ChatCompletionInput",
+        "ChatCompletionInputFunctionDefinition",
+        "ChatCompletionInputFunctionName",
+        "ChatCompletionInputGrammarType",
+        "ChatCompletionInputJSONSchema",
+        "ChatCompletionInputMessage",
+        "ChatCompletionInputMessageChunk",
+        "ChatCompletionInputMessageChunkType",
+        "ChatCompletionInputResponseFormatJSONObject",
+        "ChatCompletionInputResponseFormatJSONSchema",
+        "ChatCompletionInputResponseFormatText",
+        "ChatCompletionInputStreamOptions",
+        "ChatCompletionInputTool",
+        "ChatCompletionInputToolCall",
+        "ChatCompletionInputToolChoiceClass",
+        "ChatCompletionInputToolChoiceEnum",
+        "ChatCompletionInputURL",
+        "ChatCompletionOutput",
+        "ChatCompletionOutputComplete",
+        "ChatCompletionOutputFunctionDefinition",
+        "ChatCompletionOutputLogprob",
+        "ChatCompletionOutputLogprobs",
+        "ChatCompletionOutputMessage",
+        "ChatCompletionOutputToolCall",
+        "ChatCompletionOutputTopLogprob",
+        "ChatCompletionOutputUsage",
+        "ChatCompletionStreamOutput",
+        "ChatCompletionStreamOutputChoice",
+        "ChatCompletionStreamOutputDelta",
+        "ChatCompletionStreamOutputDeltaToolCall",
+        "ChatCompletionStreamOutputFunction",
+        "ChatCompletionStreamOutputLogprob",
+        "ChatCompletionStreamOutputLogprobs",
+        "ChatCompletionStreamOutputTopLogprob",
+        "ChatCompletionStreamOutputUsage",
+        "DepthEstimationInput",
+        "DepthEstimationOutput",
+        "DocumentQuestionAnsweringInput",
+        "DocumentQuestionAnsweringInputData",
+        "DocumentQuestionAnsweringOutputElement",
+        "DocumentQuestionAnsweringParameters",
+        "FeatureExtractionInput",
+        "FeatureExtractionInputTruncationDirection",
+        "FillMaskInput",
+        "FillMaskOutputElement",
+        "FillMaskParameters",
+        "ImageClassificationInput",
+        "ImageClassificationOutputElement",
+        "ImageClassificationOutputTransform",
+        "ImageClassificationParameters",
+        "ImageSegmentationInput",
+        "ImageSegmentationOutputElement",
+        "ImageSegmentationParameters",
+        "ImageSegmentationSubtask",
+        "ImageTextToImageInput",
+        "ImageTextToImageOutput",
+        "ImageTextToImageParameters",
+        "ImageTextToImageTargetSize",
+        "ImageTextToVideoInput",
+        "ImageTextToVideoOutput",
+        "ImageTextToVideoParameters",
+        "ImageTextToVideoTargetSize",
+        "ImageToImageInput",
+        "ImageToImageOutput",
+        "ImageToImageParameters",
+        "ImageToImageTargetSize",
+        "ImageToTextEarlyStoppingEnum",
+        "ImageToTextGenerationParameters",
+        "ImageToTextInput",
+        "ImageToTextOutput",
+        "ImageToTextParameters",
+        "ImageToVideoInput",
+        "ImageToVideoOutput",
+        "ImageToVideoParameters",
+        "ImageToVideoTargetSize",
+        "ObjectDetectionBoundingBox",
+        "ObjectDetectionInput",
+        "ObjectDetectionOutputElement",
+        "ObjectDetectionParameters",
+        "Padding",
+        "QuestionAnsweringInput",
+        "QuestionAnsweringInputData",
+        "QuestionAnsweringOutputElement",
+        "QuestionAnsweringParameters",
+        "SentenceSimilarityInput",
+        "SentenceSimilarityInputData",
+        "SummarizationInput",
+        "SummarizationOutput",
+        "SummarizationParameters",
+        "SummarizationTruncationStrategy",
+        "TableQuestionAnsweringInput",
+        "TableQuestionAnsweringInputData",
+        "TableQuestionAnsweringOutputElement",
+        "TableQuestionAnsweringParameters",
+        "Text2TextGenerationInput",
+        "Text2TextGenerationOutput",
+        "Text2TextGenerationParameters",
+        "Text2TextGenerationTruncationStrategy",
+        "TextClassificationInput",
+        "TextClassificationOutputElement",
+        "TextClassificationOutputTransform",
+        "TextClassificationParameters",
+        "TextGenerationInput",
+        "TextGenerationInputGenerateParameters",
+        "TextGenerationInputGrammarType",
+        "TextGenerationOutput",
+        "TextGenerationOutputBestOfSequence",
+        "TextGenerationOutputDetails",
+        "TextGenerationOutputFinishReason",
+        "TextGenerationOutputPrefillToken",
+        "TextGenerationOutputToken",
+        "TextGenerationStreamOutput",
+        "TextGenerationStreamOutputStreamDetails",
+        "TextGenerationStreamOutputToken",
+        "TextToAudioEarlyStoppingEnum",
+        "TextToAudioGenerationParameters",
+        "TextToAudioInput",
+        "TextToAudioOutput",
+        "TextToAudioParameters",
+        "TextToImageInput",
+        "TextToImageOutput",
+        "TextToImageParameters",
+        "TextToSpeechEarlyStoppingEnum",
+        "TextToSpeechGenerationParameters",
+        "TextToSpeechInput",
+        "TextToSpeechOutput",
+        "TextToSpeechParameters",
+        "TextToVideoInput",
+        "TextToVideoOutput",
+        "TextToVideoParameters",
+        "TokenClassificationAggregationStrategy",
+        "TokenClassificationInput",
+        "TokenClassificationOutputElement",
+        "TokenClassificationParameters",
+        "TranslationInput",
+        "TranslationOutput",
+        "TranslationParameters",
+        "TranslationTruncationStrategy",
+        "TypeEnum",
+        "VideoClassificationInput",
+        "VideoClassificationOutputElement",
+        "VideoClassificationOutputTransform",
+        "VideoClassificationParameters",
+        "VisualQuestionAnsweringInput",
+        "VisualQuestionAnsweringInputData",
+        "VisualQuestionAnsweringOutputElement",
+        "VisualQuestionAnsweringParameters",
+        "ZeroShotClassificationInput",
+        "ZeroShotClassificationOutputElement",
+        "ZeroShotClassificationParameters",
+        "ZeroShotImageClassificationInput",
+        "ZeroShotImageClassificationOutputElement",
+        "ZeroShotImageClassificationParameters",
+        "ZeroShotObjectDetectionBoundingBox",
+        "ZeroShotObjectDetectionInput",
+        "ZeroShotObjectDetectionOutputElement",
+        "ZeroShotObjectDetectionParameters",
+    ],
+    "inference._mcp.agent": [
+        "Agent",
+    ],
+    "inference._mcp.mcp_client": [
+        "MCPClient",
+    ],
+    "repocard": [
+        "DatasetCard",
+        "ModelCard",
+        "RepoCard",
+        "SpaceCard",
+        "metadata_eval_result",
+        "metadata_load",
+        "metadata_save",
+        "metadata_update",
+    ],
+    "repocard_data": [
+        "CardData",
+        "DatasetCardData",
+        "EvalResult",
+        "ModelCardData",
+        "SpaceCardData",
+    ],
+    "serialization": [
+        "StateDictSplit",
+        "get_torch_storage_id",
+        "get_torch_storage_size",
+        "load_state_dict_from_file",
+        "load_torch_model",
+        "save_torch_model",
+        "save_torch_state_dict",
+        "split_state_dict_into_shards_factory",
+        "split_torch_state_dict_into_shards",
+    ],
+    "serialization._dduf": [
+        "DDUFEntry",
+        "export_entries_as_dduf",
+        "export_folder_as_dduf",
+        "read_dduf_file",
+    ],
+    "utils": [
+        "ASYNC_CLIENT_FACTORY_T",
+        "CLIENT_FACTORY_T",
+        "CacheNotFound",
+        "CachedFileInfo",
+        "CachedIncompleteFileInfo",
+        "CachedRepoInfo",
+        "CachedRevisionInfo",
+        "CorruptedCacheException",
+        "DeleteCacheStrategy",
+        "HFCacheInfo",
+        "HfUri",
+        "cached_assets_path",
+        "close_session",
+        "dump_environment_info",
+        "get_async_session",
+        "get_session",
+        "get_token",
+        "hf_raise_for_status",
+        "logging",
+        "parse_hf_uri",
+        "scan_cache_dir",
+        "set_async_client_factory",
+        "set_client_factory",
+    ],
+}
+
+# WARNING: __all__ is generated automatically, Any manual edit will be lost when re-generating this file !
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_all_variable.py --update
+#
+# # Or run style on codebase
+# make style
+# ```
+
+__all__ = [
+    "ASYNC_CLIENT_FACTORY_T",
+    "Agent",
+    "AsyncInferenceClient",
+    "AudioClassificationInput",
+    "AudioClassificationOutputElement",
+    "AudioClassificationOutputTransform",
+    "AudioClassificationParameters",
+    "AudioToAudioInput",
+    "AudioToAudioOutputElement",
+    "AutomaticSpeechRecognitionEarlyStoppingEnum",
+    "AutomaticSpeechRecognitionGenerationParameters",
+    "AutomaticSpeechRecognitionInput",
+    "AutomaticSpeechRecognitionOutput",
+    "AutomaticSpeechRecognitionOutputChunk",
+    "AutomaticSpeechRecognitionParameters",
+    "BucketFile",
+    "BucketFileMetadata",
+    "BucketFolder",
+    "BucketInfo",
+    "BucketUrl",
+    "CLIENT_FACTORY_T",
+    "CONFIG_NAME",
+    "CacheNotFound",
+    "CachedFileInfo",
+    "CachedIncompleteFileInfo",
+    "CachedRepoInfo",
+    "CachedRevisionInfo",
+    "CardData",
+    "ChatCompletionInput",
+    "ChatCompletionInputFunctionDefinition",
+    "ChatCompletionInputFunctionName",
+    "ChatCompletionInputGrammarType",
+    "ChatCompletionInputJSONSchema",
+    "ChatCompletionInputMessage",
+    "ChatCompletionInputMessageChunk",
+    "ChatCompletionInputMessageChunkType",
+    "ChatCompletionInputResponseFormatJSONObject",
+    "ChatCompletionInputResponseFormatJSONSchema",
+    "ChatCompletionInputResponseFormatText",
+    "ChatCompletionInputStreamOptions",
+    "ChatCompletionInputTool",
+    "ChatCompletionInputToolCall",
+    "ChatCompletionInputToolChoiceClass",
+    "ChatCompletionInputToolChoiceEnum",
+    "ChatCompletionInputURL",
+    "ChatCompletionOutput",
+    "ChatCompletionOutputComplete",
+    "ChatCompletionOutputFunctionDefinition",
+    "ChatCompletionOutputLogprob",
+    "ChatCompletionOutputLogprobs",
+    "ChatCompletionOutputMessage",
+    "ChatCompletionOutputToolCall",
+    "ChatCompletionOutputTopLogprob",
+    "ChatCompletionOutputUsage",
+    "ChatCompletionStreamOutput",
+    "ChatCompletionStreamOutputChoice",
+    "ChatCompletionStreamOutputDelta",
+    "ChatCompletionStreamOutputDeltaToolCall",
+    "ChatCompletionStreamOutputFunction",
+    "ChatCompletionStreamOutputLogprob",
+    "ChatCompletionStreamOutputLogprobs",
+    "ChatCompletionStreamOutputTopLogprob",
+    "ChatCompletionStreamOutputUsage",
+    "Collection",
+    "CollectionItem",
+    "CommitInfo",
+    "CommitOperation",
+    "CommitOperationAdd",
+    "CommitOperationCopy",
+    "CommitOperationDelete",
+    "CommitScheduler",
+    "CorruptedCacheException",
+    "DDUFEntry",
+    "DatasetCard",
+    "DatasetCardData",
+    "DatasetInfo",
+    "DatasetLeaderboardEntry",
+    "DeleteCacheStrategy",
+    "DepthEstimationInput",
+    "DepthEstimationOutput",
+    "Discussion",
+    "DiscussionComment",
+    "DiscussionCommit",
+    "DiscussionEvent",
+    "DiscussionStatusChange",
+    "DiscussionTitleChange",
+    "DiscussionWithDetails",
+    "DocumentQuestionAnsweringInput",
+    "DocumentQuestionAnsweringInputData",
+    "DocumentQuestionAnsweringOutputElement",
+    "DocumentQuestionAnsweringParameters",
+    "DryRunFileInfo",
+    "DuplicatedRepoUrl",
+    "EvalResult",
+    "EvalResultEntry",
+    "FLAX_WEIGHTS_NAME",
+    "FeatureExtractionInput",
+    "FeatureExtractionInputTruncationDirection",
+    "FillMaskInput",
+    "FillMaskOutputElement",
+    "FillMaskParameters",
+    "GitCommitInfo",
+    "GitRefInfo",
+    "GitRefs",
+    "HFCacheInfo",
+    "HFSummaryWriter",
+    "HUGGINGFACE_CO_URL_HOME",
+    "HUGGINGFACE_CO_URL_TEMPLATE",
+    "HfApi",
+    "HfFileMetadata",
+    "HfFileSystem",
+    "HfFileSystemFile",
+    "HfFileSystemResolvedPath",
+    "HfFileSystemStreamFile",
+    "HfUri",
+    "ImageClassificationInput",
+    "ImageClassificationOutputElement",
+    "ImageClassificationOutputTransform",
+    "ImageClassificationParameters",
+    "ImageSegmentationInput",
+    "ImageSegmentationOutputElement",
+    "ImageSegmentationParameters",
+    "ImageSegmentationSubtask",
+    "ImageTextToImageInput",
+    "ImageTextToImageOutput",
+    "ImageTextToImageParameters",
+    "ImageTextToImageTargetSize",
+    "ImageTextToVideoInput",
+    "ImageTextToVideoOutput",
+    "ImageTextToVideoParameters",
+    "ImageTextToVideoTargetSize",
+    "ImageToImageInput",
+    "ImageToImageOutput",
+    "ImageToImageParameters",
+    "ImageToImageTargetSize",
+    "ImageToTextEarlyStoppingEnum",
+    "ImageToTextGenerationParameters",
+    "ImageToTextInput",
+    "ImageToTextOutput",
+    "ImageToTextParameters",
+    "ImageToVideoInput",
+    "ImageToVideoOutput",
+    "ImageToVideoParameters",
+    "ImageToVideoTargetSize",
+    "InferenceCatalogModel",
+    "InferenceCatalogRecipe",
+    "InferenceClient",
+    "InferenceEndpoint",
+    "InferenceEndpointError",
+    "InferenceEndpointHardware",
+    "InferenceEndpointStatus",
+    "InferenceEndpointTimeoutError",
+    "InferenceEndpointType",
+    "InferenceTimeoutError",
+    "JobAccelerator",
+    "JobDurations",
+    "JobHardware",
+    "JobHardwareInfo",
+    "JobInfo",
+    "JobInitiator",
+    "JobNetwork",
+    "JobOwner",
+    "JobStage",
+    "JobStatus",
+    "KernelInfo",
+    "MCPClient",
+    "ModelCard",
+    "ModelCardData",
+    "ModelHubMixin",
+    "ModelInfo",
+    "OAuthInfo",
+    "OAuthOrgInfo",
+    "OAuthUserInfo",
+    "ObjectDetectionBoundingBox",
+    "ObjectDetectionInput",
+    "ObjectDetectionOutputElement",
+    "ObjectDetectionParameters",
+    "Organization",
+    "PYTORCH_WEIGHTS_NAME",
+    "Padding",
+    "PyTorchModelHubMixin",
+    "QuestionAnsweringInput",
+    "QuestionAnsweringInputData",
+    "QuestionAnsweringOutputElement",
+    "QuestionAnsweringParameters",
+    "REPO_TYPE_DATASET",
+    "REPO_TYPE_MODEL",
+    "REPO_TYPE_SPACE",
+    "RepoCard",
+    "RepoFile",
+    "RepoFolder",
+    "RepoStorageInfo",
+    "RepoUrl",
+    "ResolvedRevision",
+    "Sandbox",
+    "SandboxCommandResult",
+    "SandboxPool",
+    "SandboxProcess",
+    "SentenceSimilarityInput",
+    "SentenceSimilarityInputData",
+    "SpaceCard",
+    "SpaceCardData",
+    "SpaceHardware",
+    "SpaceInfo",
+    "SpaceRuntime",
+    "SpaceSearchResult",
+    "SpaceSecret",
+    "SpaceStage",
+    "SpaceStorage",
+    "SpaceTemplate",
+    "SpaceVariable",
+    "StateDictSplit",
+    "SummarizationInput",
+    "SummarizationOutput",
+    "SummarizationParameters",
+    "SummarizationTruncationStrategy",
+    "SyncOperation",
+    "SyncPlan",
+    "TF2_WEIGHTS_NAME",
+    "TF_WEIGHTS_NAME",
+    "TableQuestionAnsweringInput",
+    "TableQuestionAnsweringInputData",
+    "TableQuestionAnsweringOutputElement",
+    "TableQuestionAnsweringParameters",
+    "Text2TextGenerationInput",
+    "Text2TextGenerationOutput",
+    "Text2TextGenerationParameters",
+    "Text2TextGenerationTruncationStrategy",
+    "TextClassificationInput",
+    "TextClassificationOutputElement",
+    "TextClassificationOutputTransform",
+    "TextClassificationParameters",
+    "TextGenerationInput",
+    "TextGenerationInputGenerateParameters",
+    "TextGenerationInputGrammarType",
+    "TextGenerationOutput",
+    "TextGenerationOutputBestOfSequence",
+    "TextGenerationOutputDetails",
+    "TextGenerationOutputFinishReason",
+    "TextGenerationOutputPrefillToken",
+    "TextGenerationOutputToken",
+    "TextGenerationStreamOutput",
+    "TextGenerationStreamOutputStreamDetails",
+    "TextGenerationStreamOutputToken",
+    "TextToAudioEarlyStoppingEnum",
+    "TextToAudioGenerationParameters",
+    "TextToAudioInput",
+    "TextToAudioOutput",
+    "TextToAudioParameters",
+    "TextToImageInput",
+    "TextToImageOutput",
+    "TextToImageParameters",
+    "TextToSpeechEarlyStoppingEnum",
+    "TextToSpeechGenerationParameters",
+    "TextToSpeechInput",
+    "TextToSpeechOutput",
+    "TextToSpeechParameters",
+    "TextToVideoInput",
+    "TextToVideoOutput",
+    "TextToVideoParameters",
+    "TokenClassificationAggregationStrategy",
+    "TokenClassificationInput",
+    "TokenClassificationOutputElement",
+    "TokenClassificationParameters",
+    "TranslationInput",
+    "TranslationOutput",
+    "TranslationParameters",
+    "TranslationTruncationStrategy",
+    "TypeEnum",
+    "User",
+    "UserLikes",
+    "VideoClassificationInput",
+    "VideoClassificationOutputElement",
+    "VideoClassificationOutputTransform",
+    "VideoClassificationParameters",
+    "VisualQuestionAnsweringInput",
+    "VisualQuestionAnsweringInputData",
+    "VisualQuestionAnsweringOutputElement",
+    "VisualQuestionAnsweringParameters",
+    "Volume",
+    "WebhookInfo",
+    "WebhookPayload",
+    "WebhookPayloadComment",
+    "WebhookPayloadDiscussion",
+    "WebhookPayloadDiscussionChanges",
+    "WebhookPayloadEvent",
+    "WebhookPayloadMovedTo",
+    "WebhookPayloadRepo",
+    "WebhookPayloadUrl",
+    "WebhookPayloadWebhook",
+    "WebhookWatchedItem",
+    "WebhooksServer",
+    "ZeroGpuQuota",
+    "ZeroShotClassificationInput",
+    "ZeroShotClassificationOutputElement",
+    "ZeroShotClassificationParameters",
+    "ZeroShotImageClassificationInput",
+    "ZeroShotImageClassificationOutputElement",
+    "ZeroShotImageClassificationParameters",
+    "ZeroShotObjectDetectionBoundingBox",
+    "ZeroShotObjectDetectionInput",
+    "ZeroShotObjectDetectionOutputElement",
+    "ZeroShotObjectDetectionParameters",
+    "_CACHED_NO_EXIST",
+    "_save_pretrained_fastai",
+    "accept_access_request",
+    "add_collection_item",
+    "add_space_secret",
+    "add_space_variable",
+    "attach_huggingface_oauth",
+    "auth_check",
+    "auth_list",
+    "auth_switch",
+    "batch_bucket_files",
+    "bucket_info",
+    "cached_assets_path",
+    "cancel_access_request",
+    "cancel_job",
+    "change_discussion_status",
+    "check_cli_update",
+    "close_session",
+    "comment_discussion",
+    "copy_files",
+    "create_branch",
+    "create_bucket",
+    "create_collection",
+    "create_commit",
+    "create_discussion",
+    "create_inference_endpoint",
+    "create_inference_endpoint_from_catalog",
+    "create_pull_request",
+    "create_repo",
+    "create_scheduled_job",
+    "create_scheduled_uv_job",
+    "create_tag",
+    "create_webhook",
+    "dataset_info",
+    "delete_branch",
+    "delete_bucket",
+    "delete_collection",
+    "delete_collection_item",
+    "delete_file",
+    "delete_folder",
+    "delete_inference_endpoint",
+    "delete_repo",
+    "delete_scheduled_job",
+    "delete_space_secret",
+    "delete_space_variable",
+    "delete_space_volumes",
+    "delete_tag",
+    "delete_webhook",
+    "disable_space_dev_mode",
+    "disable_webhook",
+    "download_bucket_files",
+    "dump_environment_info",
+    "duplicate_repo",
+    "edit_discussion_comment",
+    "enable_space_dev_mode",
+    "enable_webhook",
+    "eval_result_entries_to_yaml",
+    "export_entries_as_dduf",
+    "export_folder_as_dduf",
+    "fetch_job_logs",
+    "fetch_job_metrics",
+    "fetch_space_logs",
+    "file_exists",
+    "from_pretrained_fastai",
+    "get_async_session",
+    "get_bucket_file_metadata",
+    "get_bucket_paths_info",
+    "get_cached_repo_tree",
+    "get_collection",
+    "get_dataset_leaderboard",
+    "get_dataset_tags",
+    "get_discussion_details",
+    "get_full_repo_name",
+    "get_hf_file_metadata",
+    "get_inference_endpoint",
+    "get_local_safetensors_metadata",
+    "get_model_tags",
+    "get_organization_overview",
+    "get_paths_info",
+    "get_repo_discussions",
+    "get_safetensors_metadata",
+    "get_session",
+    "get_space_runtime",
+    "get_space_secrets",
+    "get_space_variables",
+    "get_token",
+    "get_torch_storage_id",
+    "get_torch_storage_size",
+    "get_user_overview",
+    "get_webhook",
+    "get_zero_gpu_quota",
+    "grant_access",
+    "hf_hub_download",
+    "hf_hub_url",
+    "hf_raise_for_status",
+    "hffs",
+    "inspect_job",
+    "inspect_scheduled_job",
+    "interpreter_login",
+    "is_offline_mode",
+    "kernel_info",
+    "list_accepted_access_requests",
+    "list_bucket_tree",
+    "list_buckets",
+    "list_collections",
+    "list_daily_papers",
+    "list_dataset_parquet_files",
+    "list_datasets",
+    "list_inference_catalog",
+    "list_inference_endpoints",
+    "list_inference_endpoints_hardware",
+    "list_jobs",
+    "list_jobs_hardware",
+    "list_lfs_files",
+    "list_liked_repos",
+    "list_models",
+    "list_organization_followers",
+    "list_organization_members",
+    "list_papers",
+    "list_pending_access_requests",
+    "list_rejected_access_requests",
+    "list_repo_commits",
+    "list_repo_files",
+    "list_repo_likers",
+    "list_repo_refs",
+    "list_repo_tree",
+    "list_space_templates",
+    "list_spaces",
+    "list_spaces_hardware",
+    "list_user_followers",
+    "list_user_following",
+    "list_user_repos",
+    "list_webhooks",
+    "load_state_dict_from_file",
+    "load_torch_model",
+    "logging",
+    "login",
+    "logout",
+    "merge_pull_request",
+    "metadata_eval_result",
+    "metadata_load",
+    "metadata_save",
+    "metadata_update",
+    "model_info",
+    "move_bucket",
+    "move_repo",
+    "notebook_login",
+    "paper_info",
+    "parse_eval_result_entries",
+    "parse_hf_uri",
+    "parse_huggingface_oauth",
+    "parse_local_safetensors_file_metadata",
+    "parse_safetensors_file_metadata",
+    "pause_inference_endpoint",
+    "pause_space",
+    "permanently_delete_lfs_files",
+    "preupload_lfs_files",
+    "push_to_hub_fastai",
+    "read_dduf_file",
+    "read_paper",
+    "reject_access_request",
+    "rename_discussion",
+    "repo_exists",
+    "repo_info",
+    "request_space_hardware",
+    "rerun_job",
+    "resolve_revision",
+    "restart_space",
+    "resume_inference_endpoint",
+    "resume_scheduled_job",
+    "revision_exists",
+    "run_as_future",
+    "run_job",
+    "run_uv_job",
+    "save_torch_model",
+    "save_torch_state_dict",
+    "scale_to_zero_inference_endpoint",
+    "scan_cache_dir",
+    "search_spaces",
+    "set_async_client_factory",
+    "set_client_factory",
+    "set_space_sleep_time",
+    "set_space_volumes",
+    "snapshot_download",
+    "space_info",
+    "split_state_dict_into_shards_factory",
+    "split_torch_state_dict_into_shards",
+    "super_squash_history",
+    "suspend_scheduled_job",
+    "sync_bucket",
+    "sync_job_volume",
+    "trigger_scheduled_job",
+    "try_to_load_from_cache",
+    "typer_factory",
+    "unlike",
+    "update_bucket_settings",
+    "update_collection_item",
+    "update_collection_metadata",
+    "update_collection_resource_group",
+    "update_inference_endpoint",
+    "update_job_expose",
+    "update_job_labels",
+    "update_repo_settings",
+    "update_scheduled_job_labels",
+    "update_scheduled_job_schedule",
+    "update_webhook",
+    "upload_file",
+    "upload_folder",
+    "verify_repo_checksums",
+    "wait_for_job",
+    "wait_for_space",
+    "webhook_endpoint",
+    "whoami",
+]
+
+
+def _attach(package_name, submodules=None, submod_attrs=None):
+    """Attach lazily loaded submodules, functions, or other attributes.
+
+    Typically, modules import submodules and attributes as follows:
+
+    ```py
+    import mysubmodule
+    import anothersubmodule
+
+    from .foo import someattr
+    ```
+
+    The idea is to replace a package's `__getattr__`, `__dir__`, such that all imports
+    work exactly the way they would with normal imports, except that the import occurs
+    upon first use.
+
+    The typical way to call this function, replacing the above imports, is:
+
+    ```python
+    __getattr__, __dir__ = lazy.attach(
+        __name__,
+        ['mysubmodule', 'anothersubmodule'],
+        {'foo': ['someattr']}
+    )
+    ```
+    This functionality requires Python 3.7 or higher.
+
+    Args:
+        package_name (`str`):
+            Typically use `__name__`.
+        submodules (`set`):
+            List of submodules to attach.
+        submod_attrs (`dict`):
+            Dictionary of submodule -> list of attributes / functions.
+            These attributes are imported as they are used.
+
+    Returns:
+        __getattr__, __dir__, __all__
+
+    """
+    if submod_attrs is None:
+        submod_attrs = {}
+
+    if submodules is None:
+        submodules = set()
+    else:
+        submodules = set(submodules)
+
+    attr_to_modules = {attr: mod for mod, attrs in submod_attrs.items() for attr in attrs}
+
+    def __getattr__(name):
+        if name in submodules:
+            try:
+                return importlib.import_module(f"{package_name}.{name}")
+            except Exception as e:
+                print(f"Error importing {package_name}.{name}: {e}")
+                raise
+        elif name in attr_to_modules:
+            submod_path = f"{package_name}.{attr_to_modules[name]}"
+            try:
+                submod = importlib.import_module(submod_path)
+            except Exception as e:
+                print(f"Error importing {submod_path}: {e}")
+                raise
+            attr = getattr(submod, name)
+
+            # If the attribute lives in a file (module) with the same
+            # name as the attribute, ensure that the attribute and *not*
+            # the module is accessible on the package.
+            if name == attr_to_modules[name]:
+                pkg = sys.modules[package_name]
+                pkg.__dict__[name] = attr
+
+            return attr
+        else:
+            raise AttributeError(f"No {package_name} attribute {name}")
+
+    def __dir__():
+        return __all__
+
+    return __getattr__, __dir__
+
+
+__getattr__, __dir__ = _attach(__name__, submodules=[], submod_attrs=_SUBMOD_ATTRS)
+
+if os.environ.get("EAGER_IMPORT", ""):
+    for attr in __all__:
+        __getattr__(attr)
+
+# WARNING: any content below this statement is generated automatically. Any manual edit
+# will be lost when re-generating this file !
+#
+# To update the static imports, please run the following command and commit the changes.
+# ```
+# # Use script
+# python utils/check_static_imports.py --update
+#
+# # Or run style on codebase
+# make style
+# ```
+if TYPE_CHECKING:  # pragma: no cover
+    from ._buckets import (
+        BucketFile,  # noqa: F401
+        BucketFileMetadata,  # noqa: F401
+        BucketFolder,  # noqa: F401
+        BucketInfo,  # noqa: F401
+        BucketUrl,  # noqa: F401
+        SyncOperation,  # noqa: F401
+        SyncPlan,  # noqa: F401
+    )
+    from ._commit_api import (
+        CommitOperation,  # noqa: F401
+        CommitOperationAdd,  # noqa: F401
+        CommitOperationCopy,  # noqa: F401
+        CommitOperationDelete,  # noqa: F401
+    )
+    from ._commit_scheduler import CommitScheduler  # noqa: F401
+    from ._eval_results import (
+        EvalResultEntry,  # noqa: F401
+        eval_result_entries_to_yaml,  # noqa: F401
+        parse_eval_result_entries,  # noqa: F401
+    )
+    from ._inference_endpoints import (
+        InferenceCatalogModel,  # noqa: F401
+        InferenceCatalogRecipe,  # noqa: F401
+        InferenceEndpoint,  # noqa: F401
+        InferenceEndpointError,  # noqa: F401
+        InferenceEndpointHardware,  # noqa: F401
+        InferenceEndpointStatus,  # noqa: F401
+        InferenceEndpointTimeoutError,  # noqa: F401
+        InferenceEndpointType,  # noqa: F401
+    )
+    from ._jobs_api import (
+        JobAccelerator,  # noqa: F401
+        JobDurations,  # noqa: F401
+        JobHardware,  # noqa: F401
+        JobHardwareInfo,  # noqa: F401
+        JobInfo,  # noqa: F401
+        JobInitiator,  # noqa: F401
+        JobNetwork,  # noqa: F401
+        JobOwner,  # noqa: F401
+        JobStage,  # noqa: F401
+        JobStatus,  # noqa: F401
+    )
+    from ._login import (
+        auth_list,  # noqa: F401
+        auth_switch,  # noqa: F401
+        interpreter_login,  # noqa: F401
+        login,  # noqa: F401
+        logout,  # noqa: F401
+        notebook_login,  # noqa: F401
+    )
+    from ._oauth import (
+        OAuthInfo,  # noqa: F401
+        OAuthOrgInfo,  # noqa: F401
+        OAuthUserInfo,  # noqa: F401
+        attach_huggingface_oauth,  # noqa: F401
+        parse_huggingface_oauth,  # noqa: F401
+    )
+    from ._revision import ResolvedRevision  # noqa: F401
+    from ._sandbox import (
+        Sandbox,  # noqa: F401
+        SandboxCommandResult,  # noqa: F401
+        SandboxPool,  # noqa: F401
+        SandboxProcess,  # noqa: F401
+    )
+    from ._snapshot_download import (
+        get_cached_repo_tree,  # noqa: F401
+        snapshot_download,  # noqa: F401
+    )
+    from ._space_api import (
+        SpaceHardware,  # noqa: F401
+        SpaceRuntime,  # noqa: F401
+        SpaceSecret,  # noqa: F401
+        SpaceStage,  # noqa: F401
+        SpaceStorage,  # noqa: F401
+        SpaceVariable,  # noqa: F401
+        Volume,  # noqa: F401
+        ZeroGpuQuota,  # noqa: F401
+    )
+    from ._tensorboard_logger import HFSummaryWriter  # noqa: F401
+    from ._webhooks_payload import (
+        WebhookPayload,  # noqa: F401
+        WebhookPayloadComment,  # noqa: F401
+        WebhookPayloadDiscussion,  # noqa: F401
+        WebhookPayloadDiscussionChanges,  # noqa: F401
+        WebhookPayloadEvent,  # noqa: F401
+        WebhookPayloadMovedTo,  # noqa: F401
+        WebhookPayloadRepo,  # noqa: F401
+        WebhookPayloadUrl,  # noqa: F401
+        WebhookPayloadWebhook,  # noqa: F401
+    )
+    from ._webhooks_server import (
+        WebhooksServer,  # noqa: F401
+        webhook_endpoint,  # noqa: F401
+    )
+    from .cli._cli_utils import (
+        check_cli_update,  # noqa: F401
+        typer_factory,  # noqa: F401
+    )
+    from .community import (
+        Discussion,  # noqa: F401
+        DiscussionComment,  # noqa: F401
+        DiscussionCommit,  # noqa: F401
+        DiscussionEvent,  # noqa: F401
+        DiscussionStatusChange,  # noqa: F401
+        DiscussionTitleChange,  # noqa: F401
+        DiscussionWithDetails,  # noqa: F401
+    )
+    from .constants import (
+        CONFIG_NAME,  # noqa: F401
+        FLAX_WEIGHTS_NAME,  # noqa: F401
+        HUGGINGFACE_CO_URL_HOME,  # noqa: F401
+        HUGGINGFACE_CO_URL_TEMPLATE,  # noqa: F401
+        PYTORCH_WEIGHTS_NAME,  # noqa: F401
+        REPO_TYPE_DATASET,  # noqa: F401
+        REPO_TYPE_MODEL,  # noqa: F401
+        REPO_TYPE_SPACE,  # noqa: F401
+        TF2_WEIGHTS_NAME,  # noqa: F401
+        TF_WEIGHTS_NAME,  # noqa: F401
+        is_offline_mode,  # noqa: F401
+    )
+    from .fastai_utils import (
+        _save_pretrained_fastai,  # noqa: F401
+        from_pretrained_fastai,  # noqa: F401
+        push_to_hub_fastai,  # noqa: F401
+    )
+    from .file_download import (
+        _CACHED_NO_EXIST,  # noqa: F401
+        DryRunFileInfo,  # noqa: F401
+        HfFileMetadata,  # noqa: F401
+        get_hf_file_metadata,  # noqa: F401
+        hf_hub_download,  # noqa: F401
+        hf_hub_url,  # noqa: F401
+        try_to_load_from_cache,  # noqa: F401
+    )
+    from .hf_api import (
+        Collection,  # noqa: F401
+        CollectionItem,  # noqa: F401
+        CommitInfo,  # noqa: F401
+        DatasetInfo,  # noqa: F401
+        DatasetLeaderboardEntry,  # noqa: F401
+        DuplicatedRepoUrl,  # noqa: F401
+        GitCommitInfo,  # noqa: F401
+        GitRefInfo,  # noqa: F401
+        GitRefs,  # noqa: F401
+        HfApi,  # noqa: F401
+        KernelInfo,  # noqa: F401
+        ModelInfo,  # noqa: F401
+        Organization,  # noqa: F401
+        RepoFile,  # noqa: F401
+        RepoFolder,  # noqa: F401
+        RepoStorageInfo,  # noqa: F401
+        RepoUrl,  # noqa: F401
+        SpaceInfo,  # noqa: F401
+        SpaceSearchResult,  # noqa: F401
+        SpaceTemplate,  # noqa: F401
+        User,  # noqa: F401
+        UserLikes,  # noqa: F401
+        WebhookInfo,  # noqa: F401
+        WebhookWatchedItem,  # noqa: F401
+        accept_access_request,  # noqa: F401
+        add_collection_item,  # noqa: F401
+        add_space_secret,  # noqa: F401
+        add_space_variable,  # noqa: F401
+        auth_check,  # noqa: F401
+        batch_bucket_files,  # noqa: F401
+        bucket_info,  # noqa: F401
+        cancel_access_request,  # noqa: F401
+        cancel_job,  # noqa: F401
+        change_discussion_status,  # noqa: F401
+        comment_discussion,  # noqa: F401
+        copy_files,  # noqa: F401
+        create_branch,  # noqa: F401
+        create_bucket,  # noqa: F401
+        create_collection,  # noqa: F401
+        create_commit,  # noqa: F401
+        create_discussion,  # noqa: F401
+        create_inference_endpoint,  # noqa: F401
+        create_inference_endpoint_from_catalog,  # noqa: F401
+        create_pull_request,  # noqa: F401
+        create_repo,  # noqa: F401
+        create_scheduled_job,  # noqa: F401
+        create_scheduled_uv_job,  # noqa: F401
+        create_tag,  # noqa: F401
+        create_webhook,  # noqa: F401
+        dataset_info,  # noqa: F401
+        delete_branch,  # noqa: F401
+        delete_bucket,  # noqa: F401
+        delete_collection,  # noqa: F401
+        delete_collection_item,  # noqa: F401
+        delete_file,  # noqa: F401
+        delete_folder,  # noqa: F401
+        delete_inference_endpoint,  # noqa: F401
+        delete_repo,  # noqa: F401
+        delete_scheduled_job,  # noqa: F401
+        delete_space_secret,  # noqa: F401
+        delete_space_variable,  # noqa: F401
+        delete_space_volumes,  # noqa: F401
+        delete_tag,  # noqa: F401
+        delete_webhook,  # noqa: F401
+        disable_space_dev_mode,  # noqa: F401
+        disable_webhook,  # noqa: F401
+        download_bucket_files,  # noqa: F401
+        duplicate_repo,  # noqa: F401
+        edit_discussion_comment,  # noqa: F401
+        enable_space_dev_mode,  # noqa: F401
+        enable_webhook,  # noqa: F401
+        fetch_job_logs,  # noqa: F401
+        fetch_job_metrics,  # noqa: F401
+        fetch_space_logs,  # noqa: F401
+        file_exists,  # noqa: F401
+        get_bucket_file_metadata,  # noqa: F401
+        get_bucket_paths_info,  # noqa: F401
+        get_collection,  # noqa: F401
+        get_dataset_leaderboard,  # noqa: F401
+        get_dataset_tags,  # noqa: F401
+        get_discussion_details,  # noqa: F401
+        get_full_repo_name,  # noqa: F401
+        get_inference_endpoint,  # noqa: F401
+        get_local_safetensors_metadata,  # noqa: F401
+        get_model_tags,  # noqa: F401
+        get_organization_overview,  # noqa: F401
+        get_paths_info,  # noqa: F401
+        get_repo_discussions,  # noqa: F401
+        get_safetensors_metadata,  # noqa: F401
+        get_space_runtime,  # noqa: F401
+        get_space_secrets,  # noqa: F401
+        get_space_variables,  # noqa: F401
+        get_user_overview,  # noqa: F401
+        get_webhook,  # noqa: F401
+        get_zero_gpu_quota,  # noqa: F401
+        grant_access,  # noqa: F401
+        inspect_job,  # noqa: F401
+        inspect_scheduled_job,  # noqa: F401
+        kernel_info,  # noqa: F401
+        list_accepted_access_requests,  # noqa: F401
+        list_bucket_tree,  # noqa: F401
+        list_buckets,  # noqa: F401
+        list_collections,  # noqa: F401
+        list_daily_papers,  # noqa: F401
+        list_dataset_parquet_files,  # noqa: F401
+        list_datasets,  # noqa: F401
+        list_inference_catalog,  # noqa: F401
+        list_inference_endpoints,  # noqa: F401
+        list_inference_endpoints_hardware,  # noqa: F401
+        list_jobs,  # noqa: F401
+        list_jobs_hardware,  # noqa: F401
+        list_lfs_files,  # noqa: F401
+        list_liked_repos,  # noqa: F401
+        list_models,  # noqa: F401
+        list_organization_followers,  # noqa: F401
+        list_organization_members,  # noqa: F401
+        list_papers,  # noqa: F401
+        list_pending_access_requests,  # noqa: F401
+        list_rejected_access_requests,  # noqa: F401
+        list_repo_commits,  # noqa: F401
+        list_repo_files,  # noqa: F401
+        list_repo_likers,  # noqa: F401
+        list_repo_refs,  # noqa: F401
+        list_repo_tree,  # noqa: F401
+        list_space_templates,  # noqa: F401
+        list_spaces,  # noqa: F401
+        list_spaces_hardware,  # noqa: F401
+        list_user_followers,  # noqa: F401
+        list_user_following,  # noqa: F401
+        list_user_repos,  # noqa: F401
+        list_webhooks,  # noqa: F401
+        merge_pull_request,  # noqa: F401
+        model_info,  # noqa: F401
+        move_bucket,  # noqa: F401
+        move_repo,  # noqa: F401
+        paper_info,  # noqa: F401
+        parse_local_safetensors_file_metadata,  # noqa: F401
+        parse_safetensors_file_metadata,  # noqa: F401
+        pause_inference_endpoint,  # noqa: F401
+        pause_space,  # noqa: F401
+        permanently_delete_lfs_files,  # noqa: F401
+        preupload_lfs_files,  # noqa: F401
+        read_paper,  # noqa: F401
+        reject_access_request,  # noqa: F401
+        rename_discussion,  # noqa: F401
+        repo_exists,  # noqa: F401
+        repo_info,  # noqa: F401
+        request_space_hardware,  # noqa: F401
+        rerun_job,  # noqa: F401
+        resolve_revision,  # noqa: F401
+        restart_space,  # noqa: F401
+        resume_inference_endpoint,  # noqa: F401
+        resume_scheduled_job,  # noqa: F401
+        revision_exists,  # noqa: F401
+        run_as_future,  # noqa: F401
+        run_job,  # noqa: F401
+        run_uv_job,  # noqa: F401
+        scale_to_zero_inference_endpoint,  # noqa: F401
+        search_spaces,  # noqa: F401
+        set_space_sleep_time,  # noqa: F401
+        set_space_volumes,  # noqa: F401
+        space_info,  # noqa: F401
+        super_squash_history,  # noqa: F401
+        suspend_scheduled_job,  # noqa: F401
+        sync_bucket,  # noqa: F401
+        sync_job_volume,  # noqa: F401
+        trigger_scheduled_job,  # noqa: F401
+        unlike,  # noqa: F401
+        update_bucket_settings,  # noqa: F401
+        update_collection_item,  # noqa: F401
+        update_collection_metadata,  # noqa: F401
+        update_collection_resource_group,  # noqa: F401
+        update_inference_endpoint,  # noqa: F401
+        update_job_expose,  # noqa: F401
+        update_job_labels,  # noqa: F401
+        update_repo_settings,  # noqa: F401
+        update_scheduled_job_labels,  # noqa: F401
+        update_scheduled_job_schedule,  # noqa: F401
+        update_webhook,  # noqa: F401
+        upload_file,  # noqa: F401
+        upload_folder,  # noqa: F401
+        verify_repo_checksums,  # noqa: F401
+        wait_for_job,  # noqa: F401
+        wait_for_space,  # noqa: F401
+        whoami,  # noqa: F401
+    )
+    from .hf_file_system import (
+        HfFileSystem,  # noqa: F401
+        HfFileSystemFile,  # noqa: F401
+        HfFileSystemResolvedPath,  # noqa: F401
+        HfFileSystemStreamFile,  # noqa: F401
+        hffs,  # noqa: F401
+    )
+    from .hub_mixin import (
+        ModelHubMixin,  # noqa: F401
+        PyTorchModelHubMixin,  # noqa: F401
+    )
+    from .inference._client import (
+        InferenceClient,  # noqa: F401
+        InferenceTimeoutError,  # noqa: F401
+    )
+    from .inference._generated._async_client import AsyncInferenceClient  # noqa: F401
+    from .inference._generated.types import (
+        AudioClassificationInput,  # noqa: F401
+        AudioClassificationOutputElement,  # noqa: F401
+        AudioClassificationOutputTransform,  # noqa: F401
+        AudioClassificationParameters,  # noqa: F401
+        AudioToAudioInput,  # noqa: F401
+        AudioToAudioOutputElement,  # noqa: F401
+        AutomaticSpeechRecognitionEarlyStoppingEnum,  # noqa: F401
+        AutomaticSpeechRecognitionGenerationParameters,  # noqa: F401
+        AutomaticSpeechRecognitionInput,  # noqa: F401
+        AutomaticSpeechRecognitionOutput,  # noqa: F401
+        AutomaticSpeechRecognitionOutputChunk,  # noqa: F401
+        AutomaticSpeechRecognitionParameters,  # noqa: F401
+        ChatCompletionInput,  # noqa: F401
+        ChatCompletionInputFunctionDefinition,  # noqa: F401
+        ChatCompletionInputFunctionName,  # noqa: F401
+        ChatCompletionInputGrammarType,  # noqa: F401
+        ChatCompletionInputJSONSchema,  # noqa: F401
+        ChatCompletionInputMessage,  # noqa: F401
+        ChatCompletionInputMessageChunk,  # noqa: F401
+        ChatCompletionInputMessageChunkType,  # noqa: F401
+        ChatCompletionInputResponseFormatJSONObject,  # noqa: F401
+        ChatCompletionInputResponseFormatJSONSchema,  # noqa: F401
+        ChatCompletionInputResponseFormatText,  # noqa: F401
+        ChatCompletionInputStreamOptions,  # noqa: F401
+        ChatCompletionInputTool,  # noqa: F401
+        ChatCompletionInputToolCall,  # noqa: F401
+        ChatCompletionInputToolChoiceClass,  # noqa: F401
+        ChatCompletionInputToolChoiceEnum,  # noqa: F401
+        ChatCompletionInputURL,  # noqa: F401
+        ChatCompletionOutput,  # noqa: F401
+        ChatCompletionOutputComplete,  # noqa: F401
+        ChatCompletionOutputFunctionDefinition,  # noqa: F401
+        ChatCompletionOutputLogprob,  # noqa: F401
+        ChatCompletionOutputLogprobs,  # noqa: F401
+        ChatCompletionOutputMessage,  # noqa: F401
+        ChatCompletionOutputToolCall,  # noqa: F401
+        ChatCompletionOutputTopLogprob,  # noqa: F401
+        ChatCompletionOutputUsage,  # noqa: F401
+        ChatCompletionStreamOutput,  # noqa: F401
+        ChatCompletionStreamOutputChoice,  # noqa: F401
+        ChatCompletionStreamOutputDelta,  # noqa: F401
+        ChatCompletionStreamOutputDeltaToolCall,  # noqa: F401
+        ChatCompletionStreamOutputFunction,  # noqa: F401
+        ChatCompletionStreamOutputLogprob,  # noqa: F401
+        ChatCompletionStreamOutputLogprobs,  # noqa: F401
+        ChatCompletionStreamOutputTopLogprob,  # noqa: F401
+        ChatCompletionStreamOutputUsage,  # noqa: F401
+        DepthEstimationInput,  # noqa: F401
+        DepthEstimationOutput,  # noqa: F401
+        DocumentQuestionAnsweringInput,  # noqa: F401
+        DocumentQuestionAnsweringInputData,  # noqa: F401
+        DocumentQuestionAnsweringOutputElement,  # noqa: F401
+        DocumentQuestionAnsweringParameters,  # noqa: F401
+        FeatureExtractionInput,  # noqa: F401
+        FeatureExtractionInputTruncationDirection,  # noqa: F401
+        FillMaskInput,  # noqa: F401
+        FillMaskOutputElement,  # noqa: F401
+        FillMaskParameters,  # noqa: F401
+        ImageClassificationInput,  # noqa: F401
+        ImageClassificationOutputElement,  # noqa: F401
+        ImageClassificationOutputTransform,  # noqa: F401
+        ImageClassificationParameters,  # noqa: F401
+        ImageSegmentationInput,  # noqa: F401
+        ImageSegmentationOutputElement,  # noqa: F401
+        ImageSegmentationParameters,  # noqa: F401
+        ImageSegmentationSubtask,  # noqa: F401
+        ImageTextToImageInput,  # noqa: F401
+        ImageTextToImageOutput,  # noqa: F401
+        ImageTextToImageParameters,  # noqa: F401
+        ImageTextToImageTargetSize,  # noqa: F401
+        ImageTextToVideoInput,  # noqa: F401
+        ImageTextToVideoOutput,  # noqa: F401
+        ImageTextToVideoParameters,  # noqa: F401
+        ImageTextToVideoTargetSize,  # noqa: F401
+        ImageToImageInput,  # noqa: F401
+        ImageToImageOutput,  # noqa: F401
+        ImageToImageParameters,  # noqa: F401
+        ImageToImageTargetSize,  # noqa: F401
+        ImageToTextEarlyStoppingEnum,  # noqa: F401
+        ImageToTextGenerationParameters,  # noqa: F401
+        ImageToTextInput,  # noqa: F401
+        ImageToTextOutput,  # noqa: F401
+        ImageToTextParameters,  # noqa: F401
+        ImageToVideoInput,  # noqa: F401
+        ImageToVideoOutput,  # noqa: F401
+        ImageToVideoParameters,  # noqa: F401
+        ImageToVideoTargetSize,  # noqa: F401
+        ObjectDetectionBoundingBox,  # noqa: F401
+        ObjectDetectionInput,  # noqa: F401
+        ObjectDetectionOutputElement,  # noqa: F401
+        ObjectDetectionParameters,  # noqa: F401
+        Padding,  # noqa: F401
+        QuestionAnsweringInput,  # noqa: F401
+        QuestionAnsweringInputData,  # noqa: F401
+        QuestionAnsweringOutputElement,  # noqa: F401
+        QuestionAnsweringParameters,  # noqa: F401
+        SentenceSimilarityInput,  # noqa: F401
+        SentenceSimilarityInputData,  # noqa: F401
+        SummarizationInput,  # noqa: F401
+        SummarizationOutput,  # noqa: F401
+        SummarizationParameters,  # noqa: F401
+        SummarizationTruncationStrategy,  # noqa: F401
+        TableQuestionAnsweringInput,  # noqa: F401
+        TableQuestionAnsweringInputData,  # noqa: F401
+        TableQuestionAnsweringOutputElement,  # noqa: F401
+        TableQuestionAnsweringParameters,  # noqa: F401
+        Text2TextGenerationInput,  # noqa: F401
+        Text2TextGenerationOutput,  # noqa: F401
+        Text2TextGenerationParameters,  # noqa: F401
+        Text2TextGenerationTruncationStrategy,  # noqa: F401
+        TextClassificationInput,  # noqa: F401
+        TextClassificationOutputElement,  # noqa: F401
+        TextClassificationOutputTransform,  # noqa: F401
+        TextClassificationParameters,  # noqa: F401
+        TextGenerationInput,  # noqa: F401
+        TextGenerationInputGenerateParameters,  # noqa: F401
+        TextGenerationInputGrammarType,  # noqa: F401
+        TextGenerationOutput,  # noqa: F401
+        TextGenerationOutputBestOfSequence,  # noqa: F401
+        TextGenerationOutputDetails,  # noqa: F401
+        TextGenerationOutputFinishReason,  # noqa: F401
+        TextGenerationOutputPrefillToken,  # noqa: F401
+        TextGenerationOutputToken,  # noqa: F401
+        TextGenerationStreamOutput,  # noqa: F401
+        TextGenerationStreamOutputStreamDetails,  # noqa: F401
+        TextGenerationStreamOutputToken,  # noqa: F401
+        TextToAudioEarlyStoppingEnum,  # noqa: F401
+        TextToAudioGenerationParameters,  # noqa: F401
+        TextToAudioInput,  # noqa: F401
+        TextToAudioOutput,  # noqa: F401
+        TextToAudioParameters,  # noqa: F401
+        TextToImageInput,  # noqa: F401
+        TextToImageOutput,  # noqa: F401
+        TextToImageParameters,  # noqa: F401
+        TextToSpeechEarlyStoppingEnum,  # noqa: F401
+        TextToSpeechGenerationParameters,  # noqa: F401
+        TextToSpeechInput,  # noqa: F401
+        TextToSpeechOutput,  # noqa: F401
+        TextToSpeechParameters,  # noqa: F401
+        TextToVideoInput,  # noqa: F401
+        TextToVideoOutput,  # noqa: F401
+        TextToVideoParameters,  # noqa: F401
+        TokenClassificationAggregationStrategy,  # noqa: F401
+        TokenClassificationInput,  # noqa: F401
+        TokenClassificationOutputElement,  # noqa: F401
+        TokenClassificationParameters,  # noqa: F401
+        TranslationInput,  # noqa: F401
+        TranslationOutput,  # noqa: F401
+        TranslationParameters,  # noqa: F401
+        TranslationTruncationStrategy,  # noqa: F401
+        TypeEnum,  # noqa: F401
+        VideoClassificationInput,  # noqa: F401
+        VideoClassificationOutputElement,  # noqa: F401
+        VideoClassificationOutputTransform,  # noqa: F401
+        VideoClassificationParameters,  # noqa: F401
+        VisualQuestionAnsweringInput,  # noqa: F401
+        VisualQuestionAnsweringInputData,  # noqa: F401
+        VisualQuestionAnsweringOutputElement,  # noqa: F401
+        VisualQuestionAnsweringParameters,  # noqa: F401
+        ZeroShotClassificationInput,  # noqa: F401
+        ZeroShotClassificationOutputElement,  # noqa: F401
+        ZeroShotClassificationParameters,  # noqa: F401
+        ZeroShotImageClassificationInput,  # noqa: F401
+        ZeroShotImageClassificationOutputElement,  # noqa: F401
+        ZeroShotImageClassificationParameters,  # noqa: F401
+        ZeroShotObjectDetectionBoundingBox,  # noqa: F401
+        ZeroShotObjectDetectionInput,  # noqa: F401
+        ZeroShotObjectDetectionOutputElement,  # noqa: F401
+        ZeroShotObjectDetectionParameters,  # noqa: F401
+    )
+    from .inference._mcp.agent import Agent  # noqa: F401
+    from .inference._mcp.mcp_client import MCPClient  # noqa: F401
+    from .repocard import (
+        DatasetCard,  # noqa: F401
+        ModelCard,  # noqa: F401
+        RepoCard,  # noqa: F401
+        SpaceCard,  # noqa: F401
+        metadata_eval_result,  # noqa: F401
+        metadata_load,  # noqa: F401
+        metadata_save,  # noqa: F401
+        metadata_update,  # noqa: F401
+    )
+    from .repocard_data import (
+        CardData,  # noqa: F401
+        DatasetCardData,  # noqa: F401
+        EvalResult,  # noqa: F401
+        ModelCardData,  # noqa: F401
+        SpaceCardData,  # noqa: F401
+    )
+    from .serialization import (
+        StateDictSplit,  # noqa: F401
+        get_torch_storage_id,  # noqa: F401
+        get_torch_storage_size,  # noqa: F401
+        load_state_dict_from_file,  # noqa: F401
+        load_torch_model,  # noqa: F401
+        save_torch_model,  # noqa: F401
+        save_torch_state_dict,  # noqa: F401
+        split_state_dict_into_shards_factory,  # noqa: F401
+        split_torch_state_dict_into_shards,  # noqa: F401
+    )
+    from .serialization._dduf import (
+        DDUFEntry,  # noqa: F401
+        export_entries_as_dduf,  # noqa: F401
+        export_folder_as_dduf,  # noqa: F401
+        read_dduf_file,  # noqa: F401
+    )
+    from .utils import (
+        ASYNC_CLIENT_FACTORY_T,  # noqa: F401
+        CLIENT_FACTORY_T,  # noqa: F401
+        CachedFileInfo,  # noqa: F401
+        CachedIncompleteFileInfo,  # noqa: F401
+        CachedRepoInfo,  # noqa: F401
+        CachedRevisionInfo,  # noqa: F401
+        CacheNotFound,  # noqa: F401
+        CorruptedCacheException,  # noqa: F401
+        DeleteCacheStrategy,  # noqa: F401
+        HFCacheInfo,  # noqa: F401
+        HfUri,  # noqa: F401
+        cached_assets_path,  # noqa: F401
+        close_session,  # noqa: F401
+        dump_environment_info,  # noqa: F401
+        get_async_session,  # noqa: F401
+        get_session,  # noqa: F401
+        get_token,  # noqa: F401
+        hf_raise_for_status,  # noqa: F401
+        logging,  # noqa: F401
+        parse_hf_uri,  # noqa: F401
+        scan_cache_dir,  # noqa: F401
+        set_async_client_factory,  # noqa: F401
+        set_client_factory,  # noqa: F401
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d59896ee77edf28e86a4b0156070d8c0f6116759
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_buckets.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_buckets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e32facde85a8fd0721b0b30f5b22b2b0728e9c3f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_buckets.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..52d2d671bccc827aa4613ef7afeb9f3437ee5f0c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08c78da05faf273e4bec5e7d54dd2193260ed317
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_commit_scheduler.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_dataset_viewer.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_dataset_viewer.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2cd49e80d4033cd21090c15ea60bbc19bb5c18d0
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_dataset_viewer.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_eval_results.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_eval_results.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bd0ea290732389042a953f3306a3beaf2baef29a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_eval_results.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..612da659b44b2fe7d0e839bc3cdfa165c1a346e6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_inference_endpoints.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_jobs_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_jobs_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4c4b210e9eceeaeccdda60c87745bf19bfb84283
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_jobs_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_local_folder.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_local_folder.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44e448d5afed2dc436dada9c186a4870e641f9b4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_local_folder.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9e3437a9d435230883490c064e64b15ac451824a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_login.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oauth.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oauth.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0617124066a28f1f08c77db2e0fcd3d68935301a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oauth.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oidc.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oidc.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..98af9dbb27885bc25d5fe19a4ada74a7675ff0df
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_oidc.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_revision.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_revision.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f57b9d72a99ec56cd112e88443d8467e6ba1404f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_revision.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ae157340fdabf8a2f62d8b2fd2387cc9592f0338
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6e5f0c9dc97ae1e3b074ac89a79aee4f211b19795356513a5b020d2d36725de
+size 144987
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox_cache.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox_cache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..937dbca5ae9e66cf20e3eaeea0cc69ee5ec41c52
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_sandbox_cache.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4958b506518fc6754b49af96557d10d99646f9f4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_snapshot_download.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c48cf020d3c0755677fac3c51cef154a18de36a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_space_api.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25319f31e891fe72586e8bfc4298e573531d4987
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tensorboard_logger.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tree_cache.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tree_cache.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e90c1f64ac67b5d6e80799fc79b90aad5e2c8d2
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_tree_cache.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_upload_pipeline.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_upload_pipeline.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..8eb41819efdc48a93ec33a1c139199bb04febccd
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_upload_pipeline.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f4c005c0caf3f051f92a1e8ed54c9149625554cc
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_payload.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6ecc7871c3efe4439a8ca711b3481d2f88b8ba83
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/_webhooks_server.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c58fb7650c8a92fa3b412acfc3c5100bffd9d5d4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/community.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1d6c21f5bdb95e45c1fb932f731c6144b318a95
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/constants.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/dataclasses.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/dataclasses.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c0fda5dddfd025d04d0b2f740a20cdec0ae7a99f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/dataclasses.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/errors.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/errors.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d2e24abe743bde34a1dd5c37a6520ca3ff5a1fa9
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/errors.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..027d3362bf8751e28dd98f0015ac62a730c17e51
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/fastai_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dfd3e8211a1cb0fbd9ee59790c11967ebeb187b7
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/file_download.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aab4aa93281b2945a33f15c70b26b59ddfa3f93c
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_api.cpython-311.pyc
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c7ec3075a010cd82008af3fc954f4aa5b2e85b83afc314ac336e0c88fcfa48d8
+size 719156
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0ce5325f2e40a2e0973810e04268c3ecb91f49b4
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hf_file_system.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1e8823d5670536ba842c4a55db09db2745f8a38e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/hub_mixin.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9425d2cc825079604ad387267b78ac687687b525
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/lfs.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0594f65f4189899478351824a581e957567ee981
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2014d513528132dfaea5f51476cd29fc19260e7c
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/__pycache__/repocard_data.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_buckets.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_buckets.py
new file mode 100644
index 0000000000000000000000000000000000000000..799a6a588f28e0c1d9f9a8901b80e18d332892c6
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_buckets.py
@@ -0,0 +1,1256 @@
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Shared logic for bucket operations.
+
+This module contains the core buckets logic used by both the CLI and the Python API.
+"""
+
+import fnmatch
+import json
+import mimetypes
+import os
+import stat
+import sys
+import time
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Literal
+
+from . import constants, logging
+from ._local_folder import _validate_relative_filename
+from .errors import BucketNotFoundError
+from .utils import (
+    HfUri,
+    StatusLine,
+    XetFileData,
+    disable_progress_bars,
+    enable_progress_bars,
+    parse_datetime,
+    parse_hf_uri,
+)
+from .utils._hf_uris import _looks_like_hf_url
+from .utils._paths import _normalize_separators
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+
+
+logger = logging.get_logger(__name__)
+
+
+BUCKET_PREFIX = "hf://buckets/"
+_SYNC_TIME_WINDOW_MS = 1000  # 1s safety-window for file modification time comparisons
+
+
+# =============================================================================
+# Bucket data structures
+# =============================================================================
+
+
+@dataclass
+class BucketInfo:
+    """
+    Contains information about a bucket on the Hub. This object is returned by [`bucket_info`] and [`list_buckets`].
+
+    Attributes:
+        id (`str`):
+            ID of the bucket.
+        private (`bool`):
+            Is the bucket private.
+        created_at (`datetime`):
+            Date of creation of the bucket on the Hub.
+        size (`int`):
+            Size of the bucket in bytes.
+        total_files (`int`):
+            Total number of files in the bucket.
+    """
+
+    id: str
+    private: bool
+    created_at: datetime
+    size: int
+    total_files: int
+
+    def __init__(self, **kwargs):
+        self.id = kwargs.pop("id")
+        self.private = kwargs.pop("private")
+        self.created_at = parse_datetime(kwargs.pop("createdAt"))
+        self.size = kwargs.pop("size")
+        self.total_files = kwargs.pop("totalFiles")
+        self.__dict__.update(**kwargs)
+
+
+@dataclass
+class _BucketAddFile:
+    source: str | Path | bytes
+    destination: str
+
+    xet_hash: str | None = field(default=None)
+    size: int | None = field(default=None)
+    mtime: int = field(init=False)
+    content_type: str | None = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.content_type = None
+        if isinstance(self.source, (str, Path)):  # guess content type from source path
+            self.content_type = mimetypes.guess_type(self.source)[0]
+        if self.content_type is None:  # or default to destination path content type
+            self.content_type = mimetypes.guess_type(self.destination)[0]
+
+        self.mtime = int(
+            os.path.getmtime(self.source) * 1000 if not isinstance(self.source, bytes) else time.time() * 1000
+        )
+
+
+@dataclass
+class _BucketCopyFile:
+    destination: str
+    xet_hash: str
+    source_repo_type: str  # "model", "dataset", "space", "bucket"
+    source_repo_id: str
+    size: int | None = field(default=None)
+    mtime: int = field(init=False)
+    content_type: str | None = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.content_type = mimetypes.guess_type(self.destination)[0]
+        self.mtime = int(time.time() * 1000)
+
+
+@dataclass
+class _BucketDeleteFile:
+    path: str
+
+
+@dataclass(frozen=True)
+class BucketFileMetadata:
+    """Data structure containing information about a file in a bucket.
+
+    Returned by [`get_bucket_file_metadata`].
+
+    Args:
+        size (`int`):
+            Size of the file in bytes.
+        xet_file_data (`XetFileData`):
+            Xet information for the file (hash and refresh route).
+    """
+
+    size: int
+    xet_file_data: XetFileData
+
+
+@dataclass
+class BucketUrl:
+    """Describes a bucket URL on the Hub.
+
+    `BucketUrl` is returned by [`create_bucket`]. At initialization, the URL is parsed to populate properties:
+    - endpoint (`str`)
+    - namespace (`str`)
+    - bucket_id (`str`)
+    - url (`str`)
+    - uri (`HfUri`)
+
+    Args:
+        url (`str`):
+            String value of the bucket url.
+        endpoint (`str`, *optional*):
+            Endpoint of the Hub. Defaults to <https://huggingface.co>.
+    """
+
+    url: str
+    endpoint: str = ""
+    namespace: str = field(init=False)
+    bucket_id: str = field(init=False)
+    uri: HfUri = field(init=False)
+
+    def __post_init__(self) -> None:
+        self.endpoint = self.endpoint or constants.ENDPOINT
+
+        # Parse URL: expected format is `{endpoint}/buckets/{namespace}/{bucket_name}`
+        url_path = self.url.replace(self.endpoint, "").strip("/")
+        # Remove leading "buckets/" prefix
+        if url_path.startswith("buckets/"):
+            url_path = url_path[len("buckets/") :]
+        parsed = _parse_bucket_uri(url_path)
+        if parsed.path_in_repo:
+            raise ValueError(f"Unable to parse bucket URL: {self.url}")
+        self.namespace = parsed.id.split("/")[0]
+        self.bucket_id = parsed.id
+        self.uri = parsed
+
+
+@dataclass
+class BucketFile:
+    """
+    Contains information about a file in a bucket on the Hub. This object is returned by [`list_bucket_tree`].
+
+    Similar to [`RepoFile`] but for files in buckets.
+    """
+
+    type: Literal["file"]
+    path: str
+    size: int
+    xet_hash: str
+    mtime: datetime | None
+    uploaded_at: datetime | None
+
+    def __init__(self, **kwargs):
+        self.type = kwargs.pop("type")
+        self.path = kwargs.pop("path")
+        self.size = kwargs.pop("size")
+        self.xet_hash = kwargs.pop("xetHash")
+        mtime = kwargs.pop("mtime", None)
+        self.mtime = parse_datetime(mtime) if mtime else None
+        uploaded_at = kwargs.pop("uploadedAt", None)
+        self.uploaded_at = parse_datetime(uploaded_at) if uploaded_at else None
+
+
+@dataclass
+class BucketFolder:
+    """
+    Contains information about a directory in a bucket on the Hub. This object is returned by [`list_bucket_tree`].
+
+    Similar to [`RepoFolder`] but for directories in buckets.
+    """
+
+    type: Literal["directory"]
+    path: str
+    uploaded_at: datetime | None
+
+    def __init__(self, **kwargs):
+        self.type = kwargs.pop("type")
+        self.path = kwargs.pop("path")
+        uploaded_at = kwargs.pop("uploadedAt", None) or kwargs.pop("uploaded_at", None)
+        self.uploaded_at = (
+            (uploaded_at if isinstance(uploaded_at, datetime) else parse_datetime(uploaded_at))
+            if uploaded_at
+            else None
+        )
+
+
+# =============================================================================
+# Bucket path parsing
+# =============================================================================
+
+
+def _parse_bucket_uri(path: str) -> HfUri:
+    """Parse a bucket path into a HfUri.
+
+    Accepts:
+    - `hf://buckets/namespace/name(/path/in/repo)` URIs,
+    - Hugging Face web URLs such as `https://huggingface.co/buckets/namespace/name(/tree/path)`,
+    - plain `namespace/name(/path/in/repo)` paths.
+    """
+    if path.startswith(constants.HF_PROTOCOL) or _looks_like_hf_url(path):
+        # Don't use 'if is_hf_uri(...)' here as we prefer 'parse_hf_uri(...)' to raise the exact error message.
+        parsed = parse_hf_uri(path)
+        if not parsed.is_bucket:
+            raise ValueError(f"Invalid bucket path: {path}. Must be a bucket URI (hf://buckets/...).")
+        return parsed
+    parts = path.split("/", 2)
+    if len(parts) < 2 or not parts[0] or not parts[1]:
+        raise ValueError(f"Invalid bucket path: '{path}'. Expected format: namespace/bucket_name")
+    bucket_id = f"{parts[0]}/{parts[1]}"
+    prefix = "/".join(parts[2:])
+    return HfUri(type="bucket", id=bucket_id, path_in_repo=prefix)
+
+
+def _is_bucket_path(path: str) -> bool:
+    """Check if a path is a bucket path.
+
+    Do not raise if the path is not a hf:// URI.
+    Raise if the path is a hf:// URI but with an incorrect format.
+    """
+    if not path.startswith(constants.HF_PROTOCOL):
+        return False
+    return parse_hf_uri(path).is_bucket
+
+
+# =============================================================================
+# Sync data structures
+# =============================================================================
+
+
+@dataclass
+class SyncOperation:
+    """Represents a sync operation to be performed."""
+
+    action: Literal["upload", "download", "delete", "skip"]
+    path: str
+    size: int | None = None
+    reason: str = ""
+    local_mtime: str | None = None
+    remote_mtime: str | None = None
+    bucket_file: BucketFile | None = None  # BucketFile when available (not serialized to plan file)
+
+
+@dataclass
+class SyncPlan:
+    """Represents a complete sync plan."""
+
+    source: str
+    dest: str
+    timestamp: str
+    operations: list[SyncOperation] = field(default_factory=list)
+
+    def summary(self) -> dict[str, int | str]:
+        uploads = sum(1 for op in self.operations if op.action == "upload")
+        downloads = sum(1 for op in self.operations if op.action == "download")
+        deletes = sum(1 for op in self.operations if op.action == "delete")
+        skips = sum(1 for op in self.operations if op.action == "skip")
+        total_size = sum(op.size or 0 for op in self.operations if op.action in ("upload", "download"))
+        return {
+            "uploads": uploads,
+            "downloads": downloads,
+            "deletes": deletes,
+            "skips": skips,
+            "total_size": total_size,
+        }
+
+
+# =============================================================================
+# Filter matching
+# =============================================================================
+
+
+class FilterMatcher:
+    """Matches file paths against include/exclude patterns.
+
+    Matching is case-sensitive on every platform, like bucket paths. Backslashes in patterns are treated as path
+    separators, since bucket paths and local relative paths always use `/`.
+    """
+
+    def __init__(
+        self,
+        include_patterns: list[str] | None = None,
+        exclude_patterns: list[str] | None = None,
+        filter_rules: list[tuple[str, str]] | None = None,
+    ):
+        """Initialize the filter matcher.
+
+        Args:
+            include_patterns: Patterns to include (from --include)
+            exclude_patterns: Patterns to exclude (from --exclude)
+            filter_rules: Rules from filter file as list of ("+"/"-", pattern) tuples
+        """
+        self.include_patterns = [_normalize_separators(p) for p in include_patterns or []]
+        self.exclude_patterns = [_normalize_separators(p) for p in exclude_patterns or []]
+        self.filter_rules = [(sign, _normalize_separators(p)) for sign, p in filter_rules or []]
+
+    def matches(self, path: str) -> bool:
+        """Check if a path should be included based on the filter rules.
+
+        Filtering rules:
+        - Filters are evaluated in order, first matching rule decides
+        - If no rules match, include by default (unless include patterns are specified)
+        """
+        # First check filter rules from file (in order)
+        for sign, pattern in self.filter_rules:
+            if fnmatch.fnmatchcase(path, pattern):
+                return sign == "+"
+
+        # Then check CLI patterns
+        for pattern in self.exclude_patterns:
+            if fnmatch.fnmatchcase(path, pattern):
+                return False
+
+        for pattern in self.include_patterns:
+            if fnmatch.fnmatchcase(path, pattern):
+                return True
+
+        # If include patterns were specified but none matched, exclude
+        if self.include_patterns:
+            return False
+
+        # Default: include
+        return True
+
+
+def _parse_filter_file(filter_file: str) -> list[tuple[str, str]]:
+    """Parse a filter file and return a list of (sign, pattern) tuples.
+
+    Filter file format:
+    - Lines starting with "+" are include patterns
+    - Lines starting with "-" are exclude patterns
+    - Empty lines and lines starting with "#" are ignored
+    """
+    rules = []
+    with open(filter_file) as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("+"):
+                rules.append(("+", line[1:].strip()))
+            elif line.startswith("-"):
+                rules.append(("-", line[1:].strip()))
+            else:
+                # Default to include if no prefix
+                rules.append(("+", line))
+    return rules
+
+
+# =============================================================================
+# File listing
+# =============================================================================
+
+
+def _stat_local(path: str) -> tuple[int, float] | None:
+    """Stat a local file and return (size, mtime_ms).
+
+    Returns None if the path is missing or is a directory. Uses a single
+    ``os.stat`` call so callers don't pay for multiple syscalls per file.
+    """
+    try:
+        st = os.stat(path)
+    except OSError:
+        return None
+    if stat.S_ISDIR(st.st_mode):
+        return None
+    return st.st_size, st.st_mtime * 1000
+
+
+def _list_local_files(local_path: str) -> Iterator[tuple[str, int, float]]:
+    """List all files in a local directory.
+
+    Yields:
+        tuple: (relative_path, size, mtime_ms) for each file
+    """
+    local_path = os.path.abspath(local_path)
+    if not os.path.isdir(local_path):
+        raise ValueError(f"Local path must be a directory: {local_path}")
+
+    for root, _, files in os.walk(local_path):
+        for filename in files:
+            full_path = os.path.join(root, filename)
+            stat_info = _stat_local(full_path)
+            if stat_info is None:
+                continue
+            rel_path = os.path.relpath(full_path, local_path)
+            # Normalize to forward slashes for consistency
+            rel_path = rel_path.replace(os.sep, "/")
+            yield rel_path, stat_info[0], stat_info[1]
+
+
+def _list_remote_files(api: "HfApi", bucket_id: str, prefix: str) -> Iterator[tuple[str, int, float, Any]]:
+    """List all files in a bucket with a given prefix.
+
+    Yields:
+        tuple: (relative_path, size, mtime_ms, bucket_file) for each file.
+            bucket_file is the BucketFile object from list_bucket_tree.
+    """
+    for item in api.list_bucket_tree(bucket_id, prefix=prefix or None, recursive=True):
+        if isinstance(item, BucketFolder):
+            continue
+        path = item.path
+        # Remove prefix from path to get relative path
+        # Only strip prefix if it's followed by "/" (directory boundary) or is exact match
+        if prefix:
+            if path.startswith(prefix + "/"):
+                rel_path = path[len(prefix) + 1 :]
+            elif path == prefix:
+                # Exact match: the file IS the prefix (e.g., single file download)
+                rel_path = path.rsplit("/", 1)[-1] if "/" in path else path
+            else:
+                # Path doesn't match prefix pattern (e.g., "submarine.txt" for prefix "sub")
+                # Skip this file - it was returned by the API but doesn't belong to this prefix
+                continue
+        else:
+            rel_path = path
+        # Reject server keys that would escape the local dir when joined onto it (see PR #4540).
+        _validate_relative_filename(rel_path)
+        mtime_ms = item.mtime.timestamp() * 1000 if item.mtime else 0
+        yield rel_path, item.size, mtime_ms, item
+
+
+# =============================================================================
+# Sync plan computation
+# =============================================================================
+
+
+def _mtime_to_iso(mtime_ms: float) -> str:
+    """Convert mtime in milliseconds to ISO format string."""
+    return datetime.fromtimestamp(mtime_ms / 1000, tz=timezone.utc).isoformat()
+
+
+def _compare_files_for_sync(
+    *,
+    path: str,
+    action: Literal["upload", "download"],
+    source_size: int,
+    source_mtime: float,
+    dest_size: int,
+    dest_mtime: float,
+    source_newer_label: str,
+    dest_newer_label: str,
+    ignore_sizes: bool,
+    ignore_times: bool,
+    ignore_existing: bool,
+    bucket_file: Any | None = None,
+) -> SyncOperation:
+    """Compare source and dest files and return the appropriate sync operation.
+
+    This is a unified helper for both upload and download directions.
+
+    Args:
+        path: Relative file path
+        action: "upload" or "download"
+        source_size: Size of the source file (bytes)
+        source_mtime: Mtime of the source file (milliseconds)
+        dest_size: Size of the destination file (bytes)
+        dest_mtime: Mtime of the destination file (milliseconds)
+        source_newer_label: Label when source is newer (e.g., "local newer" or "remote newer")
+        dest_newer_label: Label when dest is newer (e.g., "remote newer" or "local newer")
+        ignore_sizes: Only compare mtime
+        ignore_times: Only compare size
+        ignore_existing: Skip files that exist on receiver
+        bucket_file: BucketFile object (for downloads only)
+
+    Returns:
+        SyncOperation describing the action to take
+    """
+    local_mtime_iso = _mtime_to_iso(source_mtime if action == "upload" else dest_mtime)
+    remote_mtime_iso = _mtime_to_iso(dest_mtime if action == "upload" else source_mtime)
+
+    base_kwargs: dict[str, Any] = {
+        "path": path,
+        "size": source_size,
+        "local_mtime": local_mtime_iso,
+        "remote_mtime": remote_mtime_iso,
+    }
+
+    if ignore_existing:
+        return SyncOperation(action="skip", reason="exists on receiver (--ignore-existing)", **base_kwargs)
+
+    size_differs = source_size != dest_size
+    source_newer = (source_mtime - dest_mtime) > _SYNC_TIME_WINDOW_MS
+
+    if ignore_sizes:
+        if source_newer:
+            return SyncOperation(action=action, reason=source_newer_label, bucket_file=bucket_file, **base_kwargs)
+        else:
+            dest_newer = (dest_mtime - source_mtime) > _SYNC_TIME_WINDOW_MS
+            skip_reason = dest_newer_label if dest_newer else "same mtime"
+            return SyncOperation(action="skip", reason=skip_reason, **base_kwargs)
+    elif ignore_times:
+        if size_differs:
+            return SyncOperation(action=action, reason="size differs", bucket_file=bucket_file, **base_kwargs)
+        else:
+            return SyncOperation(action="skip", reason="same size", **base_kwargs)
+    else:
+        if size_differs or source_newer:
+            reason = "size differs" if size_differs else source_newer_label
+            return SyncOperation(action=action, reason=reason, bucket_file=bucket_file, **base_kwargs)
+        else:
+            return SyncOperation(action="skip", reason="identical", **base_kwargs)
+
+
+def _compute_sync_plan(
+    source: str,
+    dest: str,
+    api: "HfApi",
+    delete: bool = False,
+    ignore_times: bool = False,
+    ignore_sizes: bool = False,
+    existing: bool = False,
+    ignore_existing: bool = False,
+    filter_matcher: FilterMatcher | None = None,
+    status: Any | None = None,
+) -> SyncPlan:
+    """Compute the sync plan by comparing source and destination.
+
+    Returns:
+        SyncPlan with all operations to be performed
+    """
+    filter_matcher = filter_matcher or FilterMatcher()
+    is_upload = not _is_bucket_path(source) and _is_bucket_path(dest)
+    is_download = _is_bucket_path(source) and not _is_bucket_path(dest)
+
+    if not is_upload and not is_download:
+        raise ValueError("One of source or dest must be a bucket path (hf://buckets/...) and the other must be local.")
+
+    plan = SyncPlan(
+        source=source,
+        dest=dest,
+        timestamp=datetime.now(timezone.utc).isoformat(),
+    )
+
+    remote_total: int | None = None
+    if is_upload:
+        # Local -> Remote
+        local_path = os.path.abspath(source)
+        parsed = _parse_bucket_uri(dest)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+
+        if not os.path.isdir(local_path):
+            raise ValueError(f"Source must be a directory: {local_path}")
+
+        # Get local and remote file lists
+        local_files = {}
+        for rel_path, size, mtime_ms in _list_local_files(local_path):
+            if filter_matcher.matches(rel_path):
+                local_files[rel_path] = (size, mtime_ms)
+            if status:
+                status.update(f"Scanning local directory ({len(local_files)} files)")
+        if status:
+            status.done(f"Scanning local directory ({len(local_files)} files)")
+
+        remote_files = {}
+        if status:
+            try:
+                remote_total = api.bucket_info(bucket_id).total_files
+            except Exception:
+                pass
+        try:
+            for rel_path, size, mtime_ms, _ in _list_remote_files(api, bucket_id, prefix):
+                if filter_matcher.matches(rel_path):
+                    remote_files[rel_path] = (size, mtime_ms)
+                if status:
+                    total_str = f"/{remote_total}" if remote_total is not None else ""
+                    status.update(f"Scanning remote bucket ({len(remote_files)}{total_str} files)")
+        except BucketNotFoundError:
+            # Bucket doesn't exist yet - this is expected for new uploads
+            logger.debug(f"Bucket '{bucket_id}' not found, treating as empty.")
+        if status:
+            status.done(f"Scanning remote bucket ({len(remote_files)} files)")
+
+        # Compare files
+        all_paths = set(local_files.keys()) | set(remote_files.keys())
+        if status:
+            status.done(f"Comparing files ({len(all_paths)} paths)")
+        for path in sorted(all_paths):
+            local_info = local_files.get(path)
+            remote_info = remote_files.get(path)
+
+            if local_info and not remote_info:
+                # New file
+                if existing:
+                    # --existing: skip new files
+                    plan.operations.append(
+                        SyncOperation(
+                            action="skip",
+                            path=path,
+                            size=local_info[0],
+                            reason="new file (--existing)",
+                            local_mtime=_mtime_to_iso(local_info[1]),
+                        )
+                    )
+                else:
+                    plan.operations.append(
+                        SyncOperation(
+                            action="upload",
+                            path=path,
+                            size=local_info[0],
+                            reason="new file",
+                            local_mtime=_mtime_to_iso(local_info[1]),
+                        )
+                    )
+            elif local_info and remote_info:
+                # File exists in both - use helper to determine action
+                local_size, local_mtime = local_info
+                remote_size, remote_mtime = remote_info
+                plan.operations.append(
+                    _compare_files_for_sync(
+                        path=path,
+                        action="upload",
+                        source_size=local_size,
+                        source_mtime=local_mtime,
+                        dest_size=remote_size,
+                        dest_mtime=remote_mtime,
+                        source_newer_label="local newer",
+                        dest_newer_label="remote newer",
+                        ignore_sizes=ignore_sizes,
+                        ignore_times=ignore_times,
+                        ignore_existing=ignore_existing,
+                    )
+                )
+            elif not local_info and remote_info and delete:
+                # File only in remote and --delete mode
+                plan.operations.append(
+                    SyncOperation(
+                        action="delete",
+                        path=path,
+                        size=remote_info[0],
+                        reason="not in source (--delete)",
+                        remote_mtime=_mtime_to_iso(remote_info[1]),
+                    )
+                )
+
+    else:
+        # Remote -> Local (download)
+        parsed = _parse_bucket_uri(source)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+        local_path = os.path.abspath(dest)
+
+        # Get remote and local file lists
+        remote_files = {}
+        bucket_file_map: dict[str, Any] = {}
+        if status:
+            try:
+                remote_total = api.bucket_info(bucket_id).total_files
+            except Exception:
+                pass
+        for rel_path, size, mtime_ms, bucket_file in _list_remote_files(api, bucket_id, prefix):
+            if filter_matcher.matches(rel_path):
+                remote_files[rel_path] = (size, mtime_ms)
+                bucket_file_map[rel_path] = bucket_file
+            if status:
+                total_str = f"/{remote_total}" if remote_total is not None else ""
+                status.update(f"Scanning remote bucket ({len(remote_files)}{total_str} files)")
+        if status:
+            status.done(f"Scanning remote bucket ({len(remote_files)} files)")
+
+        local_files = {}
+        if os.path.isdir(local_path):
+            if delete:
+                # Full walk needed to discover local-only files for deletion.
+                for rel_path, size, mtime_ms in _list_local_files(local_path):
+                    if filter_matcher.matches(rel_path):
+                        local_files[rel_path] = (size, mtime_ms)
+                    if status:
+                        status.update(f"Scanning local directory ({len(local_files)} files)")
+            else:
+                # Without --delete, the plan only depends on paths that exist
+                # remotely. Stat just those instead of walking the whole tree,
+                # which can take minutes when dest sits in a large directory
+                # like ~/.cache/huggingface/.
+                for rel_path in remote_files:
+                    local_file = os.path.join(local_path, rel_path)
+                    stat_info = _stat_local(local_file)
+                    if stat_info is None:
+                        continue
+                    local_files[rel_path] = stat_info
+                    if status:
+                        status.update(f"Scanning local directory ({len(local_files)} files)")
+        if status:
+            status.done(f"Scanning local directory ({len(local_files)} files)")
+
+        # Compare files
+        all_paths = set(remote_files.keys()) | set(local_files.keys())
+        if status:
+            status.done(f"Comparing files ({len(all_paths)} paths)")
+        for path in sorted(all_paths):
+            remote_info = remote_files.get(path)
+            local_info = local_files.get(path)
+
+            if remote_info and not local_info:
+                # New file
+                if existing:
+                    # --existing: skip new files
+                    plan.operations.append(
+                        SyncOperation(
+                            action="skip",
+                            path=path,
+                            size=remote_info[0],
+                            reason="new file (--existing)",
+                            remote_mtime=_mtime_to_iso(remote_info[1]),
+                        )
+                    )
+                else:
+                    plan.operations.append(
+                        SyncOperation(
+                            action="download",
+                            path=path,
+                            size=remote_info[0],
+                            reason="new file",
+                            remote_mtime=_mtime_to_iso(remote_info[1]),
+                            bucket_file=bucket_file_map.get(path),
+                        )
+                    )
+            elif remote_info and local_info:
+                # File exists in both - use helper to determine action
+                remote_size, remote_mtime = remote_info
+                local_size, local_mtime = local_info
+                plan.operations.append(
+                    _compare_files_for_sync(
+                        path=path,
+                        action="download",
+                        source_size=remote_size,
+                        source_mtime=remote_mtime,
+                        dest_size=local_size,
+                        dest_mtime=local_mtime,
+                        source_newer_label="remote newer",
+                        dest_newer_label="local newer",
+                        ignore_sizes=ignore_sizes,
+                        ignore_times=ignore_times,
+                        ignore_existing=ignore_existing,
+                        bucket_file=bucket_file_map.get(path),
+                    )
+                )
+            elif not remote_info and local_info and delete:
+                # File only in local and --delete mode
+                plan.operations.append(
+                    SyncOperation(
+                        action="delete",
+                        path=path,
+                        size=local_info[0],
+                        reason="not in source (--delete)",
+                        local_mtime=_mtime_to_iso(local_info[1]),
+                    )
+                )
+
+    return plan
+
+
+# =============================================================================
+# Plan serialization
+# =============================================================================
+
+
+def _write_plan(plan: SyncPlan, f) -> None:
+    """Write a sync plan as JSONL to a file-like object."""
+    # Write header
+    header = {
+        "type": "header",
+        "source": plan.source,
+        "dest": plan.dest,
+        "timestamp": plan.timestamp,
+        "summary": plan.summary(),
+    }
+    f.write(json.dumps(header) + "\n")
+
+    # Write operations
+    for op in plan.operations:
+        op_dict: dict[str, Any] = {
+            "type": "operation",
+            "action": op.action,
+            "path": op.path,
+            "reason": op.reason,
+        }
+        if op.size is not None:
+            op_dict["size"] = op.size
+        if op.local_mtime is not None:
+            op_dict["local_mtime"] = op.local_mtime
+        if op.remote_mtime is not None:
+            op_dict["remote_mtime"] = op.remote_mtime
+        f.write(json.dumps(op_dict) + "\n")
+
+
+def _save_plan(plan: SyncPlan, plan_file: str) -> None:
+    """Save a sync plan to a JSONL file."""
+    with open(plan_file, "w") as f:
+        _write_plan(plan, f)
+
+
+def _load_plan(plan_file: str) -> SyncPlan:
+    """Load a sync plan from a JSONL file."""
+    with open(plan_file) as f:
+        lines = f.readlines()
+
+    if not lines:
+        raise ValueError(f"Empty plan file: {plan_file}")
+
+    # Parse header
+    header = json.loads(lines[0])
+    if header.get("type") != "header":
+        raise ValueError("Invalid plan file: expected header as first line")
+
+    plan = SyncPlan(
+        source=header["source"],
+        dest=header["dest"],
+        timestamp=header["timestamp"],
+    )
+
+    # Parse operations
+    for line in lines[1:]:
+        op_dict = json.loads(line)
+        if op_dict.get("type") != "operation":
+            continue
+        plan.operations.append(
+            SyncOperation(
+                action=op_dict["action"],
+                path=op_dict["path"],
+                size=op_dict.get("size"),
+                reason=op_dict.get("reason", ""),
+                local_mtime=op_dict.get("local_mtime"),
+                remote_mtime=op_dict.get("remote_mtime"),
+            )
+        )
+
+    return plan
+
+
+# =============================================================================
+# Plan execution
+# =============================================================================
+
+
+def _execute_plan(plan: SyncPlan, api: "HfApi", verbose: bool = False, status: Any | None = None) -> None:
+    """Execute a sync plan."""
+    is_upload = not _is_bucket_path(plan.source) and _is_bucket_path(plan.dest)
+    is_download = _is_bucket_path(plan.source) and not _is_bucket_path(plan.dest)
+
+    # Validate here too: an --apply'd plan is read from disk, bypassing the _list_remote_files guard.
+    for op in plan.operations:
+        _validate_relative_filename(op.path)
+
+    if is_upload:
+        local_path = os.path.abspath(plan.source)
+        parsed = _parse_bucket_uri(plan.dest)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+
+        # Collect operations
+        add_files: list[tuple[str | Path | bytes, str]] = []
+        delete_paths: list[str] = []
+
+        for op in plan.operations:
+            match op.action:
+                case "upload":
+                    local_file = os.path.join(local_path, op.path)
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    if verbose:
+                        print(f"  Uploading: {op.path} ({op.reason})")
+                    add_files.append((local_file, remote_path))
+                case "delete":
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    if verbose:
+                        print(f"  Deleting: {op.path} ({op.reason})")
+                    delete_paths.append(remote_path)
+                case "skip" if verbose:
+                    print(f"  Skipping: {op.path} ({op.reason})")
+
+        # Execute batch operations
+        if add_files or delete_paths:
+            if status:
+                parts = []
+                if add_files:
+                    parts.append(f"uploading {len(add_files)} files")
+                if delete_paths:
+                    parts.append(f"deleting {len(delete_paths)} files")
+                status.done(", ".join(parts).capitalize())
+            api.batch_bucket_files(
+                bucket_id,
+                add=add_files or None,
+                delete=delete_paths or None,
+            )
+
+    elif is_download:
+        parsed = _parse_bucket_uri(plan.source)
+        bucket_id, prefix = parsed.id, parsed.path_in_repo
+        local_path = os.path.abspath(plan.dest)
+
+        # Ensure local directory exists
+        os.makedirs(local_path, exist_ok=True)
+
+        # Collect download operations
+        download_files: list[tuple[str | BucketFile, str | Path]] = []
+        delete_files: list[str] = []
+
+        for op in plan.operations:
+            if op.action == "download":
+                local_file = os.path.join(local_path, op.path)
+                # Ensure parent directory exists
+                os.makedirs(os.path.dirname(local_file), exist_ok=True)
+                if verbose:
+                    print(f"  Downloading: {op.path} ({op.reason})")
+                # Use BucketFile when available (avoids extra metadata fetch per file)
+                if op.bucket_file is not None:
+                    download_files.append((op.bucket_file, local_file))
+                else:
+                    remote_path = f"{prefix}/{op.path}" if prefix else op.path
+                    download_files.append((remote_path, local_file))
+            elif op.action == "delete":
+                local_file = os.path.join(local_path, op.path)
+                if verbose:
+                    print(f"  Deleting: {op.path} ({op.reason})")
+                delete_files.append(local_file)
+            elif op.action == "skip" and verbose:
+                print(f"  Skipping: {op.path} ({op.reason})")
+
+        # Execute downloads
+        if len(download_files) > 0:
+            if status:
+                status.done(f"Downloading {len(download_files)} files")
+            api.download_bucket_files(bucket_id, download_files)
+
+        # Execute deletes
+        if status and delete_files:
+            status.done(f"Deleting {len(delete_files)} local files")
+        for file_path in delete_files:
+            if os.path.exists(file_path):
+                os.remove(file_path)
+                # Remove empty parent directories
+                parent = os.path.dirname(file_path)
+                while parent != local_path:
+                    try:
+                        os.rmdir(parent)
+                        parent = os.path.dirname(parent)
+                    except OSError:
+                        break
+
+
+def _print_plan_summary(plan: SyncPlan) -> None:
+    """Print a summary of the sync plan."""
+    summary = plan.summary()
+    print(f"Sync plan: {plan.source} -> {plan.dest}")
+    print(f"  Uploads: {summary['uploads']}")
+    print(f"  Downloads: {summary['downloads']}")
+    print(f"  Deletes: {summary['deletes']}")
+    print(f"  Skips: {summary['skips']}")
+
+
+# =============================================================================
+# Public sync function (Python API)
+# =============================================================================
+
+
+def sync_bucket_internal(
+    source: str | None = None,
+    dest: str | None = None,
+    *,
+    api: "HfApi",
+    delete: bool = False,
+    ignore_times: bool = False,
+    ignore_sizes: bool = False,
+    existing: bool = False,
+    ignore_existing: bool = False,
+    include: list[str] | None = None,
+    exclude: list[str] | None = None,
+    filter_from: str | None = None,
+    plan: str | None = None,
+    apply: str | None = None,
+    dry_run: bool = False,
+    verbose: bool = False,
+    quiet: bool = False,
+    token: bool | str | None = None,
+) -> SyncPlan:
+    """Sync files between a local directory and a bucket.
+
+    This is equivalent to the ``hf buckets sync`` CLI command. One of ``source`` or ``dest`` must be a bucket path
+    (``hf://buckets/...``) and the other must be a local directory path.
+
+    Args:
+        source (`str`, *optional*):
+            Source path: local directory or ``hf://buckets/namespace/bucket_name(/prefix)``.
+            Required unless using ``apply``.
+        dest (`str`, *optional*):
+            Destination path: local directory or ``hf://buckets/namespace/bucket_name(/prefix)``.
+            Required unless using ``apply``.
+        api ([`HfApi`]):
+            The HfApi instance to use for API calls.
+        delete (`bool`, *optional*, defaults to `False`):
+            Delete destination files not present in source.
+        ignore_times (`bool`, *optional*, defaults to `False`):
+            Skip files only based on size, ignoring modification times.
+        ignore_sizes (`bool`, *optional*, defaults to `False`):
+            Skip files only based on modification times, ignoring sizes.
+        existing (`bool`, *optional*, defaults to `False`):
+            Skip creating new files on receiver (only update existing files).
+        ignore_existing (`bool`, *optional*, defaults to `False`):
+            Skip updating files that exist on receiver (only create new files).
+        include (`list[str]`, *optional*):
+            Include files matching patterns (fnmatch-style).
+        exclude (`list[str]`, *optional*):
+            Exclude files matching patterns (fnmatch-style).
+        filter_from (`str`, *optional*):
+            Path to a filter file with include/exclude rules.
+        plan (`str`, *optional*):
+            Save sync plan to this JSONL file instead of executing.
+        apply (`str`, *optional*):
+            Apply a previously saved plan file. When set, ``source`` and ``dest`` are not needed.
+        dry_run (`bool`, *optional*, defaults to `False`):
+            Print sync plan to stdout as JSONL without executing.
+        verbose (`bool`, *optional*, defaults to `False`):
+            Show detailed per-file operations.
+        quiet (`bool`, *optional*, defaults to `False`):
+            Suppress all output and progress bars.
+        token (Union[bool, str, None], optional):
+            A valid user access token. If not provided, the locally saved token will be used.
+
+    Returns:
+        [`SyncPlan`]: The computed (or loaded) sync plan.
+
+    Raises:
+        `ValueError`: If arguments are invalid (e.g., both paths are remote, conflicting options).
+
+    Example:
+        ```python
+        >>> from huggingface_hub import HfApi
+        >>> api = HfApi()
+
+        # Upload local directory to bucket
+        >>> api.sync_bucket("./data", "hf://buckets/username/my-bucket")
+
+        # Download bucket to local directory
+        >>> api.sync_bucket("hf://buckets/username/my-bucket", "./data")
+
+        # Sync with delete and filtering
+        >>> api.sync_bucket(
+        ...     "./data",
+        ...     "hf://buckets/username/my-bucket",
+        ...     delete=True,
+        ...     include=["*.safetensors"],
+        ... )
+
+        # Dry run: preview what would be synced
+        >>> plan = api.sync_bucket("./data", "hf://buckets/username/my-bucket", dry_run=True)
+        >>> plan.summary()
+        {'uploads': 3, 'downloads': 0, 'deletes': 0, 'skips': 1, 'total_size': 4096}
+
+        # Save plan for review, then apply
+        >>> api.sync_bucket("./data", "hf://buckets/username/my-bucket", plan="sync-plan.jsonl")
+        >>> api.sync_bucket(apply="sync-plan.jsonl")
+        ```
+    """
+    # Build API with token if needed
+    if token is not None:
+        from .hf_api import HfApi
+
+        api = HfApi(
+            endpoint=api.endpoint,
+            token=token,
+            library_name=api.library_name,
+            library_version=api.library_version,
+            user_agent=api.user_agent,
+            headers=api.headers,
+        )
+    # --- Apply mode ---
+    if apply:
+        if source or dest:
+            raise ValueError("Cannot specify source/dest when using apply.")
+        if plan is not None:
+            raise ValueError("Cannot specify both plan and apply.")
+        if delete:
+            raise ValueError("Cannot specify delete when using apply.")
+        if ignore_times:
+            raise ValueError("Cannot specify ignore_times when using apply.")
+        if ignore_sizes:
+            raise ValueError("Cannot specify ignore_sizes when using apply.")
+        if include:
+            raise ValueError("Cannot specify include when using apply.")
+        if exclude:
+            raise ValueError("Cannot specify exclude when using apply.")
+        if filter_from:
+            raise ValueError("Cannot specify filter_from when using apply.")
+        if existing:
+            raise ValueError("Cannot specify existing when using apply.")
+        if ignore_existing:
+            raise ValueError("Cannot specify ignore_existing when using apply.")
+        if dry_run:
+            raise ValueError("Cannot specify dry_run when using apply.")
+
+        sync_plan = _load_plan(apply)
+        status = StatusLine(enabled=not quiet)
+        if not quiet:
+            _print_plan_summary(sync_plan)
+            print("Executing plan...")
+
+        if quiet:
+            disable_progress_bars()
+        try:
+            _execute_plan(sync_plan, api, verbose=verbose, status=status)
+        finally:
+            if quiet:
+                enable_progress_bars()
+
+        if not quiet:
+            print("Sync completed.")
+
+        return sync_plan
+
+    # --- Normal mode ---
+    if not source or not dest:
+        raise ValueError("Both source and dest are required (unless using apply).")
+
+    source_is_bucket = _is_bucket_path(source)
+    dest_is_bucket = _is_bucket_path(dest)
+
+    if source_is_bucket and dest_is_bucket:
+        raise ValueError("Remote to remote sync is not supported. One path must be local.")
+
+    if not source_is_bucket and not dest_is_bucket:
+        raise ValueError("One of source or dest must be a bucket path (hf://buckets/...).")
+
+    if ignore_times and ignore_sizes:
+        raise ValueError("Cannot specify both ignore_times and ignore_sizes.")
+
+    if existing and ignore_existing:
+        raise ValueError("Cannot specify both existing and ignore_existing.")
+
+    if dry_run and plan:
+        raise ValueError("Cannot specify both dry_run and plan.")
+
+    # Validate local path
+    if source_is_bucket:
+        if os.path.exists(dest) and not os.path.isdir(dest):
+            raise ValueError(f"Destination must be a directory: {dest}")
+    else:
+        if not os.path.isdir(source):
+            raise ValueError(f"Source must be an existing directory: {source}")
+
+    # Build filter matcher
+    filter_rules = None
+    if filter_from:
+        filter_rules = _parse_filter_file(filter_from)
+
+    filter_matcher = FilterMatcher(
+        include_patterns=include,
+        exclude_patterns=exclude,
+        filter_rules=filter_rules,
+    )
+
+    # Compute sync plan
+    status = StatusLine(enabled=not quiet and not dry_run)
+    sync_plan = _compute_sync_plan(
+        source=source,
+        dest=dest,
+        api=api,
+        delete=delete,
+        ignore_times=ignore_times,
+        ignore_sizes=ignore_sizes,
+        existing=existing,
+        ignore_existing=ignore_existing,
+        filter_matcher=filter_matcher,
+        status=status,
+    )
+
+    if dry_run:
+        _write_plan(sync_plan, sys.stdout)
+        return sync_plan
+
+    if plan:
+        _save_plan(sync_plan, plan)
+        if not quiet:
+            _print_plan_summary(sync_plan)
+            print(f"Plan saved to: {plan}")
+        return sync_plan
+
+    # Execute plan
+    if not quiet:
+        _print_plan_summary(sync_plan)
+
+    summary = sync_plan.summary()
+    if summary["uploads"] == 0 and summary["downloads"] == 0 and summary["deletes"] == 0:
+        if not quiet:
+            print("Nothing to sync.")
+        return sync_plan
+
+    if not quiet:
+        print("Syncing...")
+
+    if quiet:
+        disable_progress_bars()
+    try:
+        _execute_plan(sync_plan, api, verbose=verbose, status=status)
+    finally:
+        if quiet:
+            enable_progress_bars()
+
+    if not quiet:
+        print("Sync completed.")
+
+    return sync_plan
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..66ccfdf3adcc34a76c5df82bb0a361dab7069baf
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_api.py
@@ -0,0 +1,1080 @@
+"""
+Type definitions and utilities for the `create_commit` API
+"""
+
+import base64
+import io
+import json
+import os
+import warnings
+from collections import defaultdict
+from collections.abc import Iterable, Iterator
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from itertools import groupby
+from pathlib import Path, PurePosixPath
+from typing import TYPE_CHECKING, Any, BinaryIO, Literal, NamedTuple, Union
+
+from . import constants
+from .errors import EntryNotFoundError
+from .file_download import hf_hub_url
+from .lfs import UploadInfo, lfs_upload, post_lfs_batch_info
+from .utils import (
+    FORBIDDEN_FOLDERS,
+    chunk_iterable,
+    get_session,
+    hf_raise_for_status,
+    http_backoff,
+    logging,
+    sha,
+    validate_hf_hub_args,
+)
+from .utils._runtime import is_xet_available
+
+
+if TYPE_CHECKING:
+    from .hf_api import CommitInfo, RepoFile
+
+
+logger = logging.get_logger(__name__)
+
+
+UploadMode = Literal["lfs", "regular"]
+
+# Max is 1,000 per request on the Hub for HfApi.get_paths_info
+# Otherwise we get:
+# HfHubHTTPError: 413 Client Error: Payload Too Large for url: https://huggingface.co/api/datasets/xxx (Request ID: xxx)\n\ntoo many parameters
+# See https://github.com/huggingface/huggingface_hub/issues/1503
+FETCH_LFS_BATCH_SIZE = 500
+DUPLICATE_LFS_BATCH_SIZE = 500
+
+UPLOAD_BATCH_MAX_NUM_FILES = 256
+
+
+@dataclass
+class CommitOperationDelete:
+    """
+    Data structure holding necessary info to delete a file or a folder from a repository
+    on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+            for a file or `"checkpoints/1fec34a/"` for a folder.
+        is_folder (`bool` or `Literal["auto"]`, *optional*):
+            Whether the Delete Operation applies to a folder or not. If "auto", the path
+            type (file or folder) is guessed automatically by looking if path ends with
+            a "/" (folder) or not (file). To explicitly set the path type, you can set
+            `is_folder=True` or `is_folder=False`.
+    """
+
+    path_in_repo: str
+    is_folder: bool | Literal["auto"] = "auto"
+
+    def __post_init__(self):
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        if self.is_folder == "auto":
+            self.is_folder = self.path_in_repo.endswith("/")
+        if not isinstance(self.is_folder, bool):
+            raise ValueError(
+                f"Wrong value for `is_folder`. Must be one of [`True`, `False`, `'auto'`]. Got '{self.is_folder}'."
+            )
+
+
+@dataclass
+class CommitOperationCopy:
+    """
+    Data structure holding necessary info to copy a file in a repository on the Hub.
+
+    Both LFS files and regular files are supported. LFS files are copied server-side while regular files are
+    downloaded and re-uploaded as part of the commit.
+
+    Cross-repository copies are supported by setting `src_repo_id` and `src_repo_type`. For cross-repo LFS copies,
+    the LFS objects are duplicated to the destination repository before the commit is created. This is handled
+    automatically by [`create_commit`]. Note that cross-repository copies only work within the same
+    [storage region](https://huggingface.co/docs/hub/storage-regions); copying across regions is not supported.
+
+    Note: you can combine a [`CommitOperationCopy`] and a [`CommitOperationDelete`] to rename an LFS file on the Hub.
+
+    Args:
+        src_path_in_repo (`str`):
+            Relative filepath in the repo of the file to be copied, e.g. `"checkpoints/1fec34a/weights.bin"`.
+        path_in_repo (`str`):
+            Relative filepath in the repo where to copy the file, e.g. `"checkpoints/1fec34a/weights_copy.bin"`.
+        src_revision (`str`, *optional*):
+            The git revision of the file to be copied. Can be any valid git revision.
+            Default to the target commit revision.
+        src_repo_id (`str`, *optional*):
+            The source repository to copy from (e.g. `"username/source-model"`).
+            Default to the destination repository (intra-repo copy).
+        src_repo_type (`str`, *optional*):
+            The type of the source repository (`"model"`, `"dataset"` or `"space"`).
+            Required when `src_repo_id` is set.
+    """
+
+    src_path_in_repo: str
+    path_in_repo: str
+    src_revision: str | None = None
+    src_repo_id: str | None = None
+    src_repo_type: str | None = None
+    # set to the OID of the file to be copied if it has already been uploaded
+    # useful to determine if a commit will be empty or not.
+    _src_oid: str | None = None
+    # set to the OID of the file to copy to if it has already been uploaded
+    # useful to determine if a commit will be empty or not.
+    _dest_oid: str | None = None
+    # set to True once cross-repo LFS files have been duplicated to the destination repo
+    _is_duplicated: bool = False
+
+    def __post_init__(self):
+        self.src_path_in_repo = _validate_path_in_repo(self.src_path_in_repo)
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+        if self.src_repo_id is not None and self.src_repo_type is None:
+            raise ValueError("`src_repo_type` is required when `src_repo_id` is set.")
+        if self.src_repo_type is not None and self.src_repo_id is None:
+            raise ValueError("`src_repo_id` is required when `src_repo_type` is set.")
+
+
+@dataclass
+class CommitOperationAdd:
+    """
+    Data structure holding necessary info to upload a file to a repository on the Hub.
+
+    Args:
+        path_in_repo (`str`):
+            Relative filepath in the repo, for example: `"checkpoints/1fec34a/weights.bin"`
+        path_or_fileobj (`str`, `Path`, `bytes`, or `BinaryIO`):
+            Either:
+            - a path to a local file (as `str` or `pathlib.Path`) to upload
+            - a buffer of bytes (`bytes`) holding the content of the file to upload
+            - a "file object" (subclass of `io.BufferedIOBase`), typically obtained
+                with `open(path, "rb")`. It must support `seek()` and `tell()` methods.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is not one of `str`, `Path`, `bytes` or `io.BufferedIOBase`.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `str` or `Path` but not a path to an existing file.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If `path_or_fileobj` is a `io.BufferedIOBase` but it doesn't support both
+            `seek()` and `tell()`.
+    """
+
+    path_in_repo: str
+    path_or_fileobj: str | Path | bytes | BinaryIO
+    upload_info: UploadInfo = field(init=False, repr=False)
+
+    # Internal attributes
+
+    # set to "lfs" or "regular" once known
+    _upload_mode: UploadMode | None = field(init=False, repr=False, default=None)
+
+    # set to True if .gitignore rules prevent the file from being uploaded as LFS
+    # (server-side check)
+    _should_ignore: bool | None = field(init=False, repr=False, default=None)
+
+    # set to the remote OID of the file if it has already been uploaded
+    # useful to determine if a commit will be empty or not
+    _remote_oid: str | None = field(init=False, repr=False, default=None)
+
+    # set to True once the file has been uploaded as LFS
+    _is_uploaded: bool = field(init=False, repr=False, default=False)
+
+    # set to True once the file has been committed
+    _is_committed: bool = field(init=False, repr=False, default=False)
+
+    def __post_init__(self) -> None:
+        """Validates `path_or_fileobj` and compute `upload_info`."""
+        self.path_in_repo = _validate_path_in_repo(self.path_in_repo)
+
+        # Validate `path_or_fileobj` value
+        if isinstance(self.path_or_fileobj, Path):
+            self.path_or_fileobj = str(self.path_or_fileobj)
+        if isinstance(self.path_or_fileobj, str):
+            self.path_or_fileobj = os.path.normpath(os.path.expanduser(self.path_or_fileobj))
+            if not os.path.isfile(self.path_or_fileobj):
+                raise ValueError(f"Provided path: '{self.path_or_fileobj}' is not a file on the local file system")
+        elif not isinstance(self.path_or_fileobj, (io.BufferedIOBase, bytes)):
+            # ^^ Inspired from: https://stackoverflow.com/questions/44584829/how-to-determine-if-file-is-opened-in-binary-or-text-mode
+            raise ValueError(
+                "path_or_fileobj must be either an instance of str, bytes or"
+                " io.BufferedIOBase. If you passed a file-like object, make sure it is"
+                " in binary mode."
+            )
+        if isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            try:
+                self.path_or_fileobj.tell()
+                self.path_or_fileobj.seek(0, os.SEEK_CUR)
+            except (OSError, AttributeError) as exc:
+                raise ValueError(
+                    "path_or_fileobj is a file-like object but does not implement seek() and tell()"
+                ) from exc
+
+        # Compute "upload_info" attribute
+        if isinstance(self.path_or_fileobj, str):
+            self.upload_info = UploadInfo.from_path(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, bytes):
+            self.upload_info = UploadInfo.from_bytes(self.path_or_fileobj)
+        else:
+            self.upload_info = UploadInfo.from_fileobj(self.path_or_fileobj)
+
+    @contextmanager
+    def as_file(self, with_tqdm: bool = False) -> Iterator[BinaryIO]:
+        """
+        A context manager that yields a file-like object allowing to read the underlying
+        data behind `path_or_fileobj`.
+
+        Args:
+            with_tqdm (`bool`, *optional*, defaults to `False`):
+                If True, iterating over the file object will display a progress bar. Only
+                works if the file-like object is a path to a file. Pure bytes and buffers
+                are not supported.
+
+        Example:
+
+        ```python
+        >>> operation = CommitOperationAdd(
+        ...        path_in_repo="remote/dir/weights.h5",
+        ...        path_or_fileobj="./local/weights.h5",
+        ... )
+        CommitOperationAdd(path_in_repo='remote/dir/weights.h5', path_or_fileobj='./local/weights.h5')
+
+        >>> with operation.as_file() as file:
+        ...     content = file.read()
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     while True:
+        ...         data = file.read(1024)
+        ...         if not data:
+        ...              break
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+
+        >>> with operation.as_file(with_tqdm=True) as file:
+        ...     httpx2.put(..., data=file)
+        config.json: 100%|█████████████████████████| 8.19k/8.19k [00:02<00:00, 3.72kB/s]
+        ```
+        """
+        if isinstance(self.path_or_fileobj, str) or isinstance(self.path_or_fileobj, Path):
+            if with_tqdm:
+                from .utils import tqdm_stream_file
+
+                with tqdm_stream_file(self.path_or_fileobj) as file:
+                    yield file
+            else:
+                with open(self.path_or_fileobj, "rb") as file:
+                    yield file
+        elif isinstance(self.path_or_fileobj, bytes):
+            yield io.BytesIO(self.path_or_fileobj)
+        elif isinstance(self.path_or_fileobj, io.BufferedIOBase):
+            prev_pos = self.path_or_fileobj.tell()
+            yield self.path_or_fileobj
+            self.path_or_fileobj.seek(prev_pos, io.SEEK_SET)
+
+    def b64content(self) -> bytes:
+        """
+        The base64-encoded content of `path_or_fileobj`
+
+        Returns: `bytes`
+        """
+        with self.as_file() as file:
+            return base64.b64encode(file.read())
+
+    @property
+    def _local_oid(self) -> str | None:
+        """Return the OID of the local file.
+
+        This OID is then compared to `self._remote_oid` to check if the file has changed compared to the remote one.
+        If the file did not change, we won't upload it again to prevent empty commits.
+
+        For LFS files, the OID corresponds to the SHA256 of the file content (used a LFS ref).
+        For regular files, the OID corresponds to the SHA1 of the file content.
+        Note: this is slightly different to git OID computation since the oid of an LFS file is usually the git-SHA1 of the
+              pointer file content (not the actual file content). However, using the SHA256 is enough to detect changes
+              and more convenient client-side.
+        """
+        if self._upload_mode is None:
+            return None
+        elif self._upload_mode == "lfs":
+            return self.upload_info.sha256.hex()
+        else:
+            # Regular file => compute sha1
+            # => no need to read by chunk since the file is guaranteed to be <=5MB.
+            with self.as_file() as file:
+                return sha.git_hash(file.read())
+
+
+def _validate_path_in_repo(path_in_repo: str) -> str:
+    # Validate `path_in_repo` value to prevent a server-side issue
+    if path_in_repo.startswith("/"):
+        path_in_repo = path_in_repo[1:]
+    # Reject any ".." segment, wherever it sits in the path: a segment in the middle
+    # (e.g. "a/../../etc/passwd" or "a/../file.txt") is not caught by a prefix check
+    # and can still escape the repo root once resolved.
+    if path_in_repo == "." or any(part == ".." for part in path_in_repo.split("/")):
+        raise ValueError(f"Invalid `path_in_repo` in CommitOperation: '{path_in_repo}'")
+    if path_in_repo.startswith("./"):
+        path_in_repo = path_in_repo[2:]
+    for forbidden in FORBIDDEN_FOLDERS:
+        if any(part == forbidden for part in path_in_repo.split("/")):
+            raise ValueError(
+                f"Invalid `path_in_repo` in CommitOperation: cannot update files under a '{forbidden}/' folder (path:"
+                f" '{path_in_repo}')."
+            )
+    return path_in_repo
+
+
+CommitOperation = Union[CommitOperationAdd, CommitOperationCopy, CommitOperationDelete]
+
+
+def _warn_on_overwriting_operations(operations: list[CommitOperation]) -> None:
+    """
+    Warn user when a list of operations is expected to overwrite itself in a single
+    commit.
+
+    Rules:
+    - If a filepath is updated by multiple `CommitOperationAdd` operations, a warning
+      message is triggered.
+    - If a filepath is updated at least once by a `CommitOperationAdd` and then deleted
+      by a `CommitOperationDelete`, a warning is triggered.
+    - If a `CommitOperationDelete` deletes a filepath that is then updated by a
+      `CommitOperationAdd`, no warning is triggered. This is usually useless (no need to
+      delete before upload) but can happen if a user deletes an entire folder and then
+      add new files to it.
+    """
+    nb_additions_per_path: dict[str, int] = defaultdict(int)
+    for operation in operations:
+        path_in_repo = operation.path_in_repo
+        if isinstance(operation, CommitOperationAdd):
+            if nb_additions_per_path[path_in_repo] > 0:
+                warnings.warn(
+                    "About to update multiple times the same file in the same commit:"
+                    f" '{path_in_repo}'. This can cause undesired inconsistencies in"
+                    " your repo."
+                )
+            nb_additions_per_path[path_in_repo] += 1
+            for parent in PurePosixPath(path_in_repo).parents:
+                # Also keep track of number of updated files per folder
+                # => warns if deleting a folder overwrite some contained files
+                nb_additions_per_path[str(parent)] += 1
+        if isinstance(operation, CommitOperationDelete):
+            if nb_additions_per_path[str(PurePosixPath(path_in_repo))] > 0:
+                if operation.is_folder:
+                    warnings.warn(
+                        "About to delete a folder containing files that have just been"
+                        f" updated within the same commit: '{path_in_repo}'. This can"
+                        " cause undesired inconsistencies in your repo."
+                    )
+                else:
+                    warnings.warn(
+                        "About to delete a file that have just been updated within the"
+                        f" same commit: '{path_in_repo}'. This can cause undesired"
+                        " inconsistencies in your repo."
+                    )
+
+
+@validate_hf_hub_args
+def _upload_files(
+    *,
+    additions: list[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    num_threads: int = 5,
+    revision: str | None = None,
+    create_pr: bool | None = None,
+):
+    """
+    Uploads the files through the Xet protocol if possible, otherwise through the legacy LFS protocol.
+
+    The Xet path does not require any Python-side sha256 computation: hashing happens inside `hf_xet`
+    while chunking the files (single read pass) and is backfilled on the operations afterwards.
+    """
+    has_buffered_io_data = any(isinstance(op.path_or_fileobj, io.BufferedIOBase) for op in additions)
+    if is_xet_available():
+        if not has_buffered_io_data:
+            _upload_xet_files(
+                additions=additions,
+                repo_type=repo_type,
+                repo_id=repo_id,
+                headers=headers,
+                endpoint=endpoint,
+                revision=revision,
+                create_pr=create_pr,
+            )
+            return
+        logger.warning(
+            "Uploading files as a binary IO buffer is not supported by Xet Storage. Falling back to HTTP upload."
+        )
+
+    # Legacy LFS path: sha256 is required by the LFS batch endpoint => compute missing ones (in parallel).
+    _compute_missing_sha256s(additions, num_threads=num_threads)
+
+    lfs_actions: list[dict[str, Any]] = []
+    lfs_oid2addop: dict[str, CommitOperationAdd] = {}
+    for chunk in chunk_iterable(additions, chunk_size=UPLOAD_BATCH_MAX_NUM_FILES):
+        chunk_list = [op for op in chunk]
+        actions_chunk, errors_chunk, _ = post_lfs_batch_info(
+            upload_infos=[op.upload_info for op in chunk_list],
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=revision,
+            endpoint=endpoint,
+            headers=headers,
+            token=None,  # already passed in 'headers'
+            transfers=["basic", "multipart"],
+        )
+        if errors_chunk:
+            message = "\n".join(
+                [
+                    f"Encountered error for file with OID {err.get('oid')}: `{err.get('error', {}).get('message')}"
+                    for err in errors_chunk
+                ]
+            )
+            raise ValueError(f"LFS batch API returned errors:\n{message}")
+        lfs_actions.extend(actions_chunk)
+        for op in chunk_list:
+            lfs_oid2addop[op.upload_info.sha256.hex()] = op
+
+    if len(lfs_actions) > 0:
+        _upload_lfs_files(
+            actions=lfs_actions,
+            oid2addop=lfs_oid2addop,
+            headers=headers,
+            endpoint=endpoint,
+            num_threads=num_threads,
+        )
+
+
+def _compute_missing_sha256s(additions: list[CommitOperationAdd], num_threads: int) -> None:
+    """Compute the sha256 of the operations that don't have one yet, in parallel."""
+    not_hashed = [op for op in additions if not op.upload_info.is_hashed]
+    if len(not_hashed) == 0:
+        return
+    logger.info(f"Computing sha256 for {len(not_hashed)} files.")
+    if len(not_hashed) == 1:
+        _ = not_hashed[0].upload_info.sha256
+        return
+    with ThreadPoolExecutor(max_workers=num_threads) as executor:
+        list(executor.map(lambda op: op.upload_info.sha256, not_hashed))
+
+
+@validate_hf_hub_args
+def _upload_lfs_files(
+    *,
+    actions: list[dict[str, Any]],
+    oid2addop: dict[str, CommitOperationAdd],
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    num_threads: int = 5,
+):
+    """
+    Uploads the content of `additions` to the Hub using the large file storage protocol.
+
+    Relevant external documentation:
+        - LFS Batch API: https://github.com/git-lfs/git-lfs/blob/main/docs/api/batch.md
+
+    Args:
+        actions (`list[dict[str, Any]]`):
+            LFS batch actions returned by the server.
+        oid2addop (`dict[str, CommitOperationAdd]`):
+            A dictionary mapping the OID of the file to the corresponding `CommitOperationAdd` object.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        endpoint (`str`, *optional*):
+            The endpoint to use for the request. Defaults to `constants.ENDPOINT`.
+        num_threads (`int`, *optional*):
+            The number of concurrent threads to use when uploading. Defaults to 5.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        num_threads (`int`, *optional*):
+            The number of concurrent threads to use when uploading. Defaults to 5.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the server returns malformed responses
+        [`HfHubHTTPError`]
+            If the LFS batch endpoint returned an HTTP error.
+    """
+    # Filter out files already present upstream
+    filtered_actions = []
+    for action in actions:
+        if action.get("actions") is None:
+            logger.debug(
+                f"Content of file {oid2addop[action['oid']].path_in_repo} is already present upstream - skipping upload."
+            )
+        else:
+            filtered_actions.append(action)
+
+    # Upload according to server-provided actions
+    def _wrapped_lfs_upload(batch_action) -> None:
+        try:
+            operation = oid2addop[batch_action["oid"]]
+            lfs_upload(operation=operation, lfs_batch_action=batch_action, headers=headers, endpoint=endpoint)
+        except Exception as exc:
+            raise RuntimeError(f"Error while uploading '{operation.path_in_repo}' to the Hub.") from exc
+
+    if len(filtered_actions) == 1:
+        logger.debug("Uploading 1 LFS file to the Hub")
+        _wrapped_lfs_upload(filtered_actions[0])
+    else:
+        logger.debug(
+            f"Uploading {len(filtered_actions)} LFS files to the Hub using up to {num_threads} threads concurrently"
+        )
+        from .utils import hf_thread_map
+        from .utils import tqdm as hf_tqdm
+
+        hf_thread_map(
+            _wrapped_lfs_upload,
+            filtered_actions,
+            desc=f"Upload {len(filtered_actions)} LFS files",
+            max_workers=num_threads,
+            tqdm_class=hf_tqdm,
+        )
+
+
+@validate_hf_hub_args
+def _upload_xet_files(
+    *,
+    additions: list[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    endpoint: str | None = None,
+    revision: str | None = None,
+    create_pr: bool | None = None,
+):
+    """
+    Uploads the content of `additions` to the Hub using the xet storage protocol.
+    This chunks the files and deduplicates the chunks before uploading them to xetcas storage.
+
+    Args:
+        additions (`` of `CommitOperationAdd`):
+            The files to be uploaded.
+        repo_type (`str`):
+            Type of the repo (e.g. `"model"`, `"dataset"`, `"space"`).
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        endpoint: (`str`, *optional*):
+            The endpoint to use for the xetcas service. Defaults to `constants.ENDPOINT`.
+        revision (`str`, *optional*):
+            The git revision to upload to.
+        create_pr (`bool`, *optional*):
+            Whether or not to create a Pull Request with that commit.
+
+    Raises:
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If an upload failed for any reason.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the server returns malformed responses or if the user is unauthorized to upload to xet storage.
+        [`HfHubHTTPError`]
+            If the LFS batch endpoint returned an HTTP error.
+
+    **How it works:**
+        The file upload system uses Xet storage, which is a content-addressable storage system that breaks files into chunks
+        for efficient storage and transfer.
+
+        ``session.new_upload_commit()`` manages uploading files by:
+            - Registering upload tasks and starting upload immediately in the background
+            - Breaking files into smaller chunks for efficient storage
+            - Avoiding duplicate storage by recognizing identical chunks across files
+            - Connecting to a storage server (CAS server) that manages these chunks
+
+        Authentication works transparently: the upload commit accepts a ``token_refresh_url``
+        that is used to refresh the short-lived xet write token as needed.
+
+        The upload process works like this:
+        1. Upload tasks run in parallel:
+            1.1. Read the file content from a path, bytes array, or a stream.
+            1.2. Split the file content into smaller chunks based on content patterns: each chunk gets a unique ID based on what's in it.
+            1.3. For each chunk:
+                - Check if it already exists in storage.
+                - Skip uploading chunks that already exist.
+            1.4. Group chunks into larger blocks for efficient transfer.
+            1.5. Upload these blocks to the storage server.
+            1.6. Assemble the file manifest locally and send it to the server for validation.
+        2. Return reference files that contain information about the uploaded files, which can be used later to download them.
+    """
+    if len(additions) == 0:
+        return
+
+    # at this point, we know that hf_xet is installed
+    from .utils._xet import (
+        XetTokenType,
+        abort_xet_session,
+        get_xet_session,
+        xet_connection_info_refresh_url,
+        xet_headers_without_auth,
+    )
+    from .utils._xet_progress_reporting import XetUploadProgressReporter
+
+    refresh_url = xet_connection_info_refresh_url(
+        token_type=XetTokenType.WRITE,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        revision=revision,
+        endpoint=endpoint,
+    )
+    if create_pr:
+        refresh_url += "?create_pr=1"
+
+    xet_headers = xet_headers_without_auth(headers)
+
+    import hf_xet
+
+    session = get_xet_session()
+    progress = None
+
+    def _sha256_arg(op: CommitOperationAdd):
+        # If the sha256 is already known, pass it to avoid recomputation. Otherwise let hf_xet
+        # compute it while chunking the file (single read pass) and backfill it afterwards.
+        return op.upload_info.sha256.hex() if op.upload_info.is_hashed else hf_xet.COMPUTE_SHA256
+
+    try:
+        from .utils import are_progress_bars_disabled
+
+        if not are_progress_bars_disabled():
+            progress = XetUploadProgressReporter()
+            progress_callback = progress.update_progress
+        else:
+            progress_callback = None
+
+        all_bytes_ops = [op for op in additions if isinstance(op.path_or_fileobj, bytes)]
+        all_paths_ops = [op for op in additions if isinstance(op.path_or_fileobj, (str, Path))]
+
+        handles: list[tuple[CommitOperationAdd, Any]] = []
+        with session.new_upload_commit(
+            token_refresh_url=refresh_url,
+            token_refresh_headers=headers,
+            custom_headers=xet_headers,
+            progress_callback=progress_callback,
+        ) as commit:
+            for op in all_paths_ops:
+                handles.append((op, commit.start_upload_file(str(op.path_or_fileobj), sha256=_sha256_arg(op))))
+            for op in all_bytes_ops:
+                handles.append((op, commit.start_upload_bytes(op.path_or_fileobj, sha256=_sha256_arg(op))))
+
+        # Backfill sha256 computed by hf_xet (needed later for the commit payload).
+        for op, handle in handles:
+            if not op.upload_info.is_hashed:
+                op.upload_info.sha256 = bytes.fromhex(handle.result().xet_info.sha256)
+    except KeyboardInterrupt:
+        abort_xet_session()
+        raise
+    finally:
+        if progress is not None:
+            progress.close()
+
+
+def _validate_preupload_info(preupload_info: dict):
+    files = preupload_info.get("files")
+    if not isinstance(files, list):
+        raise ValueError("preupload_info is improperly formatted")
+    for file_info in files:
+        if not (
+            isinstance(file_info, dict)
+            and isinstance(file_info.get("path"), str)
+            and isinstance(file_info.get("uploadMode"), str)
+            and (file_info["uploadMode"] in ("lfs", "regular"))
+        ):
+            raise ValueError("preupload_info is improperly formatted:")
+    return preupload_info
+
+
+@validate_hf_hub_args
+def _fetch_upload_modes(
+    additions: Iterable[CommitOperationAdd],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+    create_pr: bool = False,
+    gitignore_content: str | None = None,
+) -> None:
+    """
+    Requests the Hub "preupload" endpoint to determine whether each input file should be uploaded as a regular git blob,
+    as a git LFS blob, or as a XET file. Input `additions` are mutated in-place with the upload mode.
+
+    Args:
+        additions (`Iterable` of :class:`CommitOperationAdd`):
+            Iterable of :class:`CommitOperationAdd` describing the files to
+            upload to the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+        gitignore_content (`str`, *optional*):
+            The content of the `.gitignore` file to know which files should be ignored. The order of priority
+            is to first check if `gitignore_content` is passed, then check if the `.gitignore` file is present
+            in the list of files to commit and finally default to the `.gitignore` file already hosted on the Hub
+            (if any).
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+
+    # Fetch upload mode (LFS or regular) chunk by chunk.
+    upload_modes: dict[str, UploadMode] = {}
+    should_ignore_info: dict[str, bool] = {}
+    oid_info: dict[str, str | None] = {}
+
+    for chunk in chunk_iterable(additions, 256):
+        payload: dict = {
+            "files": [
+                {
+                    "path": op.path_in_repo,
+                    "sample": base64.b64encode(op.upload_info.sample).decode("ascii"),
+                    "size": op.upload_info.size,
+                }
+                for op in chunk
+            ]
+        }
+        if gitignore_content is not None:
+            payload["gitIgnore"] = gitignore_content
+
+        resp = http_backoff(
+            "POST",
+            f"{endpoint}/api/{repo_type}s/{repo_id}/preupload/{revision}",
+            json=payload,
+            headers=headers,
+            params={"create_pr": "1"} if create_pr else None,
+        )
+        hf_raise_for_status(resp)
+        preupload_info = _validate_preupload_info(resp.json())
+        upload_modes.update(**{file["path"]: file["uploadMode"] for file in preupload_info["files"]})
+        should_ignore_info.update(**{file["path"]: file["shouldIgnore"] for file in preupload_info["files"]})
+        oid_info.update(**{file["path"]: file.get("oid") for file in preupload_info["files"]})
+
+    # Set upload mode for each addition operation
+    for addition in additions:
+        addition._upload_mode = upload_modes[addition.path_in_repo]
+        addition._should_ignore = should_ignore_info[addition.path_in_repo]
+        addition._remote_oid = oid_info[addition.path_in_repo]
+
+    # Empty files cannot be uploaded as LFS (S3 would fail with a 501 Not Implemented)
+    # => empty files are uploaded as "regular" to still allow users to commit them.
+    for addition in additions:
+        if addition.upload_info.size == 0:
+            addition._upload_mode = "regular"
+
+
+class _CopySource(NamedTuple):
+    src_repo_id: str | None
+    src_repo_type: str | None
+    path: str
+    revision: str | None
+
+
+@validate_hf_hub_args
+def _fetch_files_to_copy(
+    copies: Iterable[CommitOperationCopy],
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+) -> dict[_CopySource, Union["RepoFile", bytes]]:
+    """
+    Fetch information about the files to copy.
+
+    For LFS files, we only need their metadata (file size and sha256) while for regular files
+    we need to download the raw content from the Hub.
+
+    Args:
+        copies (`Iterable` of :class:`CommitOperationCopy`):
+            Iterable of :class:`CommitOperationCopy` describing the files to
+            copy on the Hub.
+        repo_type (`str`):
+            Type of the repo to upload to: `"model"`, `"dataset"` or `"space"`.
+        repo_id (`str`):
+            A namespace (user or an organization) and a repo name separated
+            by a `/`.
+        headers (`dict[str, str]`):
+            Headers to use for the request, including authorization headers and user agent.
+        revision (`str`):
+            The git revision to upload the files to. Can be any valid git revision.
+
+    Returns: `dict[_CopySource, Union[RepoFile, bytes]]]`
+        Key is `(src_repo_id, src_repo_type, path, revision)`. For intra-repo copies,
+        `src_repo_id` and `src_repo_type` are `None`.
+        Value is the raw content as bytes (for regular files) or the file information as a RepoFile (for LFS files).
+
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If the Hub API response is improperly formatted.
+    """
+    from .hf_api import HfApi, RepoFolder
+
+    hf_api = HfApi(endpoint=endpoint, headers=headers)
+    copies = list(copies)
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]] = {}
+    oid_info: dict[tuple[str, str | None], str | None] = {}
+
+    # 1. Fetch OIDs for destination paths in batches.
+    dest_paths = [op.path_in_repo for op in copies]
+    for batch in chunk_iterable(dest_paths, FETCH_LFS_BATCH_SIZE):
+        dest_repo_files = hf_api.get_paths_info(
+            repo_id=repo_id,
+            paths=list(batch),
+            revision=revision,
+            repo_type=repo_type,
+        )
+        for file in dest_repo_files:
+            if not isinstance(file, RepoFolder):
+                oid_info[(file.path, revision)] = file.blob_id
+
+    # 2. Fetch source file info, grouped by (src_repo_id, src_repo_type, src_revision).
+    copies.sort(key=lambda op: (op.src_repo_id or "", op.src_repo_type or "", op.src_revision or ""))
+    for (src_repo_id_key, src_repo_type_key, src_revision_key), group in groupby(
+        copies, key=lambda op: (op.src_repo_id, op.src_repo_type, op.src_revision)
+    ):
+        operations = list(group)
+        is_cross_repo = src_repo_id_key is not None
+        eff_repo_id = src_repo_id_key or repo_id
+        eff_repo_type = src_repo_type_key or repo_type
+        eff_revision = src_revision_key or ("main" if is_cross_repo else revision)
+
+        src_paths = [op.src_path_in_repo for op in operations]
+        for paths_batch in chunk_iterable(src_paths, FETCH_LFS_BATCH_SIZE):
+            src_repo_files = hf_api.get_paths_info(
+                repo_id=eff_repo_id,
+                paths=list(paths_batch),
+                revision=eff_revision,
+                repo_type=eff_repo_type,
+            )
+            for src_repo_file in src_repo_files:
+                if isinstance(src_repo_file, RepoFolder):
+                    raise NotImplementedError("Copying a folder is not implemented.")
+                source = _CopySource(src_repo_id_key, src_repo_type_key, src_repo_file.path, src_revision_key)
+                if src_repo_file.lfs:
+                    files_to_copy[source] = src_repo_file
+                else:
+                    url = hf_hub_url(
+                        endpoint=endpoint,
+                        repo_type=eff_repo_type,
+                        repo_id=eff_repo_id,
+                        revision=eff_revision,
+                        filename=src_repo_file.path,
+                    )
+                    response = get_session().get(url, headers=headers)
+                    hf_raise_for_status(response)
+                    files_to_copy[source] = response.content
+                if not is_cross_repo:
+                    oid_info[(src_repo_file.path, src_revision_key)] = src_repo_file.blob_id
+
+        for operation in operations:
+            key = _CopySource(src_repo_id_key, src_repo_type_key, operation.src_path_in_repo, src_revision_key)
+            if key not in files_to_copy:
+                source_desc = f" from {eff_repo_type}s/{eff_repo_id}" if is_cross_repo else ""
+                raise EntryNotFoundError(
+                    f"Cannot copy {operation.src_path_in_repo} at revision "
+                    f"{eff_revision}{source_desc}: file is missing on repo."
+                )
+            operation._dest_oid = oid_info.get((operation.path_in_repo, revision))
+            if not is_cross_repo:
+                operation._src_oid = oid_info.get((operation.src_path_in_repo, operation.src_revision))
+
+    return files_to_copy
+
+
+def _prepare_commit_payload(
+    operations: Iterable[CommitOperation],
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]],
+    commit_message: str,
+    commit_description: str | None = None,
+    parent_commit: str | None = None,
+) -> Iterable[dict[str, Any]]:
+    """
+    Builds the payload to POST to the `/commit` API of the Hub.
+
+    Payload is returned as an iterator so that it can be streamed as a ndjson in the
+    POST request.
+
+    For more information, see:
+        - https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+        - http://ndjson.org/
+    """
+    commit_description = commit_description if commit_description is not None else ""
+
+    # 1. Send a header item with the commit metadata
+    header_value = {"summary": commit_message, "description": commit_description}
+    if parent_commit is not None:
+        header_value["parentCommit"] = parent_commit
+    yield {"key": "header", "value": header_value}
+
+    nb_ignored_files = 0
+
+    # 2. Send operations, one per line
+    for operation in operations:
+        # Skip ignored files
+        if isinstance(operation, CommitOperationAdd) and operation._should_ignore:
+            logger.debug(f"Skipping file '{operation.path_in_repo}' in commit (ignored by gitignore file).")
+            nb_ignored_files += 1
+            continue
+
+        # 2.a. Case adding a regular file
+        if isinstance(operation, CommitOperationAdd) and operation._upload_mode == "regular":
+            yield {
+                "key": "file",
+                "value": {
+                    "content": operation.b64content().decode(),
+                    "path": operation.path_in_repo,
+                    "encoding": "base64",
+                },
+            }
+        # 2.b. Case adding an LFS file
+        elif isinstance(operation, CommitOperationAdd) and operation._upload_mode == "lfs":
+            yield {
+                "key": "lfsFile",
+                "value": {
+                    "path": operation.path_in_repo,
+                    "algo": "sha256",
+                    "oid": operation.upload_info.sha256.hex(),
+                    "size": operation.upload_info.size,
+                },
+            }
+        # 2.c. Case deleting a file or folder
+        elif isinstance(operation, CommitOperationDelete):
+            yield {
+                "key": "deletedFolder" if operation.is_folder else "deletedFile",
+                "value": {"path": operation.path_in_repo},
+            }
+        # 2.d. Case copying a file or folder
+        elif isinstance(operation, CommitOperationCopy):
+            source = _CopySource(
+                operation.src_repo_id,
+                operation.src_repo_type,
+                operation.src_path_in_repo,
+                operation.src_revision,
+            )
+            file_to_copy = files_to_copy[source]
+            if isinstance(file_to_copy, bytes):
+                yield {
+                    "key": "file",
+                    "value": {
+                        "content": base64.b64encode(file_to_copy).decode(),
+                        "path": operation.path_in_repo,
+                        "encoding": "base64",
+                    },
+                }
+            elif file_to_copy.lfs:
+                yield {
+                    "key": "lfsFile",
+                    "value": {
+                        "path": operation.path_in_repo,
+                        "algo": "sha256",
+                        "oid": file_to_copy.lfs.sha256,
+                    },
+                }
+            else:
+                raise ValueError(
+                    "Malformed files_to_copy (should be raw file content as bytes or RepoFile objects with LFS info."
+                )
+        # 2.e. Never expected to happen
+        else:
+            raise ValueError(
+                f"Unknown operation to commit. Operation: {operation}. Upload mode:"
+                f" {getattr(operation, '_upload_mode', None)}"
+            )
+
+    if nb_ignored_files > 0:
+        logger.info(f"Skipped {nb_ignored_files} file(s) in commit (ignored by gitignore file).")
+
+
+def _send_commit(
+    *,
+    operations: Iterable[CommitOperation],
+    files_to_copy: dict[_CopySource, Union["RepoFile", bytes]],
+    commit_message: str,
+    commit_description: str,
+    repo_type: str,
+    repo_id: str,
+    headers: dict[str, str],
+    revision: str,
+    endpoint: str | None = None,
+    parent_commit: str | None = None,
+    create_pr: bool = False,
+    hot_reload: bool = False,
+    retry_on_error: bool = False,
+) -> "CommitInfo":
+    """
+    Build the ndjson payload for `operations` and POST it to the `/commit` endpoint of the Hub.
+
+    `revision` must already be URL-quoted. Operations must be ready to commit: upload modes fetched
+    and LFS/Xet content uploaded.
+
+    If `retry_on_error` is `True`, the POST is retried with exponential backoff on transient errors.
+    Caution: if a commit succeeds but its response is lost, the retry will create a duplicate commit
+    (and a duplicate pull request if `create_pr` is set) — only enable it when this is acceptable.
+
+    Returns a [`CommitInfo`] built from the server response.
+
+    Raises:
+        [`~utils.HfHubHTTPError`]
+            If the Hub API returned an error.
+    """
+    endpoint = endpoint if endpoint is not None else constants.ENDPOINT
+    payload = _prepare_commit_payload(
+        operations=operations,
+        files_to_copy=files_to_copy,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        parent_commit=parent_commit,
+    )
+    data = b"".join(json.dumps(item).encode() + b"\n" for item in payload)
+    # See https://github.com/huggingface/huggingface_hub/issues/1085#issuecomment-1265208073
+    headers = {"Content-Type": "application/x-ndjson", **headers}
+    url = f"{endpoint}/api/{repo_type}s/{repo_id}/commit/{revision}"
+
+    params: dict[str, str] = {}
+    if create_pr:
+        params["create_pr"] = "1"
+    if hot_reload:
+        params["hot_reload"] = "1"
+
+    if retry_on_error:
+        response = http_backoff("POST", url, headers=headers, content=data, params=params)
+    else:
+        response = get_session().post(url, headers=headers, content=data, params=params)
+    hf_raise_for_status(response, endpoint_name="commit")
+
+    commit_data = response.json()
+    from .hf_api import CommitInfo
+
+    return CommitInfo(
+        commit_url=commit_data["commitUrl"],
+        commit_message=commit_message,
+        commit_description=commit_description,
+        oid=commit_data["commitOid"],
+        pr_url=commit_data["pullRequestUrl"] if create_pr else None,
+        _endpoint=endpoint,
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py
new file mode 100644
index 0000000000000000000000000000000000000000..f48f42fd114e11aaf055f9e25386d2caea2c30e5
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_commit_scheduler.py
@@ -0,0 +1,353 @@
+import atexit
+import logging
+import os
+import time
+from concurrent.futures import Future
+from dataclasses import dataclass
+from io import SEEK_END, SEEK_SET, BytesIO
+from pathlib import Path
+from threading import Lock, Thread
+from typing import Optional
+
+from ._commit_api import CommitOperationAdd
+from .hf_api import DEFAULT_IGNORE_PATTERNS, CommitInfo, HfApi
+from .utils import filter_repo_objects
+
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class _FileToUpload:
+    """Temporary dataclass to store info about files to upload. Not meant to be used directly."""
+
+    local_path: Path
+    path_in_repo: str
+    size_limit: int
+    last_modified: float
+
+
+class CommitScheduler:
+    """
+    Scheduler to upload a local folder to the Hub at regular intervals (e.g. push to hub every 5 minutes).
+
+    The recommended way to use the scheduler is to use it as a context manager. This ensures that the scheduler is
+    properly stopped and the last commit is triggered when the script ends. The scheduler can also be stopped manually
+    with the `stop` method. Checkout the [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#scheduled-uploads)
+    to learn more about how to use it.
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to commit to.
+        folder_path (`str` or `Path`):
+            Path to the local folder to upload regularly.
+        every (`int` or `float`, *optional*):
+            The number of minutes between each commit. Defaults to 5 minutes.
+        path_in_repo (`str`, *optional*):
+            Relative path of the directory in the repo, for example: `"checkpoints/"`. Defaults to the root folder
+            of the repository.
+        repo_type (`str`, *optional*):
+            The type of the repo to commit to. Defaults to `model`.
+        revision (`str`, *optional*):
+            The revision of the repo to commit to. Defaults to `main`.
+        private (`bool`, *optional*):
+            Whether to make the repo private. If `None` (default), the repo will be public unless the organization's default is private. This value is ignored if the repo already exists.
+        token (`str`, *optional*):
+            The token to use to commit to the repo. Defaults to the token saved on the machine.
+        allow_patterns (`list[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are uploaded.
+        ignore_patterns (`list[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not uploaded.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        hf_api (`HfApi`, *optional*):
+            The [`HfApi`] client to use to commit to the Hub. Can be set with custom settings (user agent, token,...).
+
+    Example:
+    ```py
+    >>> from pathlib import Path
+    >>> from huggingface_hub import CommitScheduler
+
+    # Scheduler uploads every 10 minutes
+    >>> csv_path = Path("watched_folder/data.csv")
+    >>> CommitScheduler(repo_id="test_scheduler", repo_type="dataset", folder_path=csv_path.parent, every=10)
+
+    >>> with csv_path.open("a") as f:
+    ...     f.write("first line")
+
+    # Some time later (...)
+    >>> with csv_path.open("a") as f:
+    ...     f.write("second line")
+    ```
+
+    Example using a context manager:
+    ```py
+    >>> from pathlib import Path
+    >>> from huggingface_hub import CommitScheduler
+
+    >>> with CommitScheduler(repo_id="test_scheduler", repo_type="dataset", folder_path="watched_folder", every=10) as scheduler:
+    ...     csv_path = Path("watched_folder/data.csv")
+    ...     with csv_path.open("a") as f:
+    ...         f.write("first line")
+    ...     (...)
+    ...     with csv_path.open("a") as f:
+    ...         f.write("second line")
+
+    # Scheduler is now stopped and last commit have been triggered
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        repo_id: str,
+        folder_path: str | Path,
+        every: int | float = 5,
+        path_in_repo: str | None = None,
+        repo_type: str | None = None,
+        revision: str | None = None,
+        private: bool | None = None,
+        token: str | None = None,
+        allow_patterns: list[str] | str | None = None,
+        ignore_patterns: list[str] | str | None = None,
+        squash_history: bool = False,
+        hf_api: Optional["HfApi"] = None,
+    ) -> None:
+        self.api = hf_api or HfApi(token=token)
+
+        # Folder
+        self.folder_path = Path(folder_path).expanduser().resolve()
+        self.path_in_repo = path_in_repo or ""
+        self.allow_patterns = allow_patterns
+
+        if ignore_patterns is None:
+            ignore_patterns = []
+        elif isinstance(ignore_patterns, str):
+            ignore_patterns = [ignore_patterns]
+        self.ignore_patterns = ignore_patterns + DEFAULT_IGNORE_PATTERNS
+
+        if self.folder_path.is_file():
+            raise ValueError(f"'folder_path' must be a directory, not a file: '{self.folder_path}'.")
+        self.folder_path.mkdir(parents=True, exist_ok=True)
+
+        # Repository
+        repo_url = self.api.create_repo(repo_id=repo_id, private=private, repo_type=repo_type, exist_ok=True)
+        self.repo_id = repo_url.repo_id
+        self.repo_type = repo_type
+        self.revision = revision
+        self.token = token
+
+        # Keep track of already uploaded files
+        self.last_uploaded: dict[Path, float] = {}  # key is local path, value is timestamp
+
+        # Scheduler
+        if not every > 0:
+            raise ValueError(f"'every' must be a positive integer, not '{every}'.")
+        self.lock = Lock()
+        self.every = every
+        self.squash_history = squash_history
+        self.__stopped = False
+
+        logger.info(f"Scheduled job to push '{self.folder_path}' to '{self.repo_id}' every {self.every} minutes.")
+        self._scheduler_thread = Thread(target=self._run_scheduler, daemon=True)
+        self._scheduler_thread.start()
+        atexit.register(self._push_to_hub)
+
+    def stop(self) -> None:
+        """Stop the scheduler.
+
+        A stopped scheduler cannot be restarted. Mostly for tests purposes.
+        """
+        self.__stopped = True
+
+    def __enter__(self) -> "CommitScheduler":
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback) -> None:
+        # Upload last changes before exiting
+        self.trigger().result()
+        self.stop()
+        return
+
+    def _run_scheduler(self) -> None:
+        """Dumb thread waiting between each scheduled push to Hub."""
+        while True:
+            self.last_future = self.trigger()
+            time.sleep(self.every * 60)
+            if self.__stopped:
+                break
+
+    def trigger(self) -> Future:
+        """Trigger a `push_to_hub` and return a future.
+
+        This method is automatically called every `every` minutes. You can also call it manually to trigger a commit
+        immediately, without waiting for the next scheduled commit.
+        """
+        return self.api.run_as_future(self._push_to_hub)
+
+    def _push_to_hub(self) -> CommitInfo | None:
+        if self.__stopped:  # If stopped, already scheduled commits are ignored
+            return None
+
+        logger.info("(Background) scheduled commit triggered.")
+        try:
+            value = self.push_to_hub()
+            if self.squash_history:
+                logger.info("(Background) squashing repo history.")
+                self.api.super_squash_history(repo_id=self.repo_id, repo_type=self.repo_type, branch=self.revision)
+            return value
+        except Exception as e:
+            logger.error(f"Error while pushing to Hub: {e}")  # Depending on the setup, error might be silenced
+            raise
+
+    def push_to_hub(self) -> CommitInfo | None:
+        """
+        Push folder to the Hub and return the commit info.
+
+        > [!WARNING]
+        > This method is not meant to be called directly. It is run in the background by the scheduler, respecting a
+        > queue mechanism to avoid concurrent commits. Making a direct call to the method might lead to concurrency
+        > issues.
+
+        The default behavior of `push_to_hub` is to assume an append-only folder. It lists all files in the folder and
+        uploads only changed files. If no changes are found, the method returns without committing anything. If you want
+        to change this behavior, you can inherit from [`CommitScheduler`] and override this method. This can be useful
+        for example to compress data together in a single file before committing. For more details and examples, check
+        out our [integration guide](https://huggingface.co/docs/huggingface_hub/main/en/guides/upload#scheduled-uploads).
+        """
+        # Check files to upload (with lock)
+        with self.lock:
+            logger.debug("Listing files to upload for scheduled commit.")
+
+            # List files from folder (taken from `_prepare_upload_folder_additions`)
+            relpath_to_abspath = {
+                path.relative_to(self.folder_path).as_posix(): path
+                for path in sorted(self.folder_path.glob("**/*"))  # sorted to be deterministic
+                if path.is_file()
+            }
+            prefix = f"{self.path_in_repo.strip('/')}/" if self.path_in_repo else ""
+
+            # Filter with pattern + filter out unchanged files + retrieve current file size
+            files_to_upload: list[_FileToUpload] = []
+            for relpath in filter_repo_objects(
+                relpath_to_abspath.keys(), allow_patterns=self.allow_patterns, ignore_patterns=self.ignore_patterns
+            ):
+                local_path = relpath_to_abspath[relpath]
+                stat = local_path.stat()
+                if self.last_uploaded.get(local_path) is None or self.last_uploaded[local_path] != stat.st_mtime:
+                    files_to_upload.append(
+                        _FileToUpload(
+                            local_path=local_path,
+                            path_in_repo=prefix + relpath,
+                            size_limit=stat.st_size,
+                            last_modified=stat.st_mtime,
+                        )
+                    )
+
+        # Return if nothing to upload
+        if len(files_to_upload) == 0:
+            logger.debug("Dropping schedule commit: no changed file to upload.")
+            return None
+
+        # Convert `_FileToUpload` as `CommitOperationAdd` (=> compute file shas + limit to file size)
+        logger.debug("Removing unchanged files since previous scheduled commit.")
+        add_operations = [
+            CommitOperationAdd(
+                # Cap the file to its current size, even if the user append data to it while a scheduled commit is happening
+                path_or_fileobj=PartialFileIO(file_to_upload.local_path, size_limit=file_to_upload.size_limit),
+                path_in_repo=file_to_upload.path_in_repo,
+            )
+            for file_to_upload in files_to_upload
+        ]
+
+        # Upload files (append mode expected - no need for lock)
+        logger.debug("Uploading files for scheduled commit.")
+        commit_info = self.api.create_commit(
+            repo_id=self.repo_id,
+            repo_type=self.repo_type,
+            operations=add_operations,
+            commit_message="Scheduled Commit",
+            revision=self.revision,
+        )
+
+        # Successful commit: keep track of the latest "last_modified" for each file
+        for file in files_to_upload:
+            self.last_uploaded[file.local_path] = file.last_modified
+        return commit_info
+
+
+class PartialFileIO(BytesIO):
+    """A file-like object that reads only the first part of a file.
+
+    Useful to upload a file to the Hub when the user might still be appending data to it. Only the first part of the
+    file is uploaded (i.e. the part that was available when the filesystem was first scanned).
+
+    In practice, only used internally by the CommitScheduler to regularly push a folder to the Hub with minimal
+    disturbance for the user. The object is passed to `CommitOperationAdd`.
+
+    Only supports `read`, `tell` and `seek` methods.
+
+    Args:
+        file_path (`str` or `Path`):
+            Path to the file to read.
+        size_limit (`int`):
+            The maximum number of bytes to read from the file. If the file is larger than this, only the first part
+            will be read (and uploaded).
+    """
+
+    def __init__(self, file_path: str | Path, size_limit: int) -> None:
+        self._file_path = Path(file_path)
+        self._file = self._file_path.open("rb")
+        self._size_limit = min(size_limit, os.fstat(self._file.fileno()).st_size)
+
+    def __del__(self) -> None:
+        self._file.close()
+        return super().__del__()
+
+    def __repr__(self) -> str:
+        return f"<PartialFileIO file_path={self._file_path} size_limit={self._size_limit}>"
+
+    def __len__(self) -> int:
+        return self._size_limit
+
+    def __getattribute__(self, name: str):
+        if name.startswith("_") or name in ("read", "tell", "seek", "fileno"):  # only 4 public methods supported
+            return super().__getattribute__(name)
+        raise NotImplementedError(f"PartialFileIO does not support '{name}'.")
+
+    def fileno(self):
+        raise AttributeError("PartialFileIO does not have a fileno.")
+
+    def tell(self) -> int:
+        """Return the current file position."""
+        return self._file.tell()
+
+    def seek(self, __offset: int, __whence: int = SEEK_SET) -> int:
+        """Change the stream position to the given offset.
+
+        Behavior is the same as a regular file, except that the position is capped to the size limit.
+        """
+        if __whence == SEEK_END:
+            # SEEK_END => set from the truncated end
+            __offset = len(self) + __offset
+            __whence = SEEK_SET
+
+        pos = self._file.seek(__offset, __whence)
+        if pos > self._size_limit:
+            return self._file.seek(self._size_limit)
+        return pos
+
+    def read(self, __size: int | None = -1) -> bytes:
+        """Read at most `__size` bytes from the file.
+
+        Behavior is the same as a regular file, except that it is capped to the size limit.
+        """
+        current = self._file.tell()
+        if __size is None or __size < 0:
+            # Read until file limit
+            truncated_size = self._size_limit - current
+        else:
+            # Read until file limit or __size
+            truncated_size = min(__size, self._size_limit - current)
+        return self._file.read(truncated_size)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_dataset_viewer.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_dataset_viewer.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c3a773df47ef946e81368deabc1e4b9f4eda724
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_dataset_viewer.py
@@ -0,0 +1,173 @@
+# Copyright 2026 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.
+import json
+import os
+import shutil
+import subprocess
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Union
+
+from . import constants
+from .utils import get_token
+
+
+if TYPE_CHECKING:
+    import duckdb
+
+
+@dataclass(frozen=True)
+class DatasetParquetEntry:
+    """Represents a single parquet file available for a dataset on the Hub."""
+
+    config: str
+    split: str
+    url: str
+    size: int
+
+
+def execute_raw_sql_query(sql_query: str, *, token: str | bool | None = None) -> list[dict[str, Any]]:
+    normalized_query = sql_query.strip().rstrip(";").strip()
+    _raise_on_forbidden_query(normalized_query)
+
+    connection = None
+    try:
+        connection = _get_duckdb_connection(token=token)
+        relation = connection.sql(normalized_query)
+        if relation is None:
+            raise ValueError("SQL query must return rows.")
+
+        if isinstance(relation, _DuckDBCliRelation):
+            # DuckDB binary => run CLI => parse JSON
+            return relation.execute()
+        else:
+            # DuckDB Python API => fetch columns + rows => convert to dicts
+            columns = tuple(column[0] for column in relation.description)
+            rows = tuple(tuple(row) for row in relation.fetchall())
+            return [dict(zip(columns, row)) for row in rows]
+    finally:
+        if connection is not None:
+            connection.close()
+
+
+def _raise_on_forbidden_query(query: str) -> None:
+    if len(query) == 0:
+        raise ValueError("SQL query cannot be empty.")
+
+    # DuckDB CLI meta-commands are dot-prefixed words (e.g. `.shell`, `.output`).
+    # Let's forbid them for now but allow SQL expressions like `.5` that can legitimately start a line.
+    for line in query.splitlines():
+        stripped = line.lstrip()
+        if stripped.startswith(".") and stripped[1:2].isalpha():
+            raise ValueError("DuckDB CLI meta-commands are not allowed in SQL queries.")
+
+
+def _get_duckdb_connection(
+    token: str | bool | None,
+) -> Union["duckdb.DuckDBPyConnection", "_DuckDBCliConnection"]:
+    try:
+        # If DuckDB is installed as a Python package, use it!
+        import duckdb
+    except ImportError as error:
+        # Otherwise, use the DuckDB CLI binary.
+        duckdb_binary = shutil.which("duckdb")
+        if duckdb_binary is None:
+            raise ImportError(
+                "DuckDB is required for `hf datasets sql`. Install the Python package with `pip install duckdb` or "
+                "install the DuckDB CLI binary (for example `brew install duckdb`)."
+            ) from error
+        return _DuckDBCliConnection(binary_path=duckdb_binary, token=token)
+
+    # Create a new connection (Python API).
+    connection = duckdb.connect()
+    try:
+        for statement in _build_duckdb_secret_statements(token):
+            connection.execute(statement)
+        return connection
+    except Exception:
+        connection.close()
+        raise
+
+
+@dataclass
+class _DuckDBCliConnection:
+    """DuckDB connection.
+
+    Mimics the DuckDB Python API, but runs the queries via the DuckDB CLI binary.
+    """
+
+    binary_path: str
+    token: str | bool | None
+
+    def __post_init__(self) -> None:
+        self._setup_statements = _build_duckdb_secret_statements(self.token)
+
+    def sql(self, query: str) -> "_DuckDBCliRelation":
+        return _DuckDBCliRelation(binary_path=self.binary_path, setup_statements=self._setup_statements, query=query)
+
+    def close(self) -> None:
+        pass
+
+
+@dataclass
+class _DuckDBCliRelation:
+    """DuckDB relation.
+
+    Mimics the DuckDB Python API, but runs the queries via the DuckDB CLI binary.
+    """
+
+    binary_path: str
+    setup_statements: list[str]
+    query: str
+
+    def execute(self) -> list[dict[str, Any]]:
+        # Build the DuckDB CLI input.
+        setup = []
+        if self.setup_statements:
+            setup = [
+                f".output {os.devnull}",
+                *(f"{stmt};" for stmt in self.setup_statements),
+                ".output",
+            ]
+        full_query = "\n".join(setup + [self.query + ";"])
+
+        # Run DuckDB binary
+        result = subprocess.run(
+            [self.binary_path, "-json"],
+            input=full_query,
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            check=False,
+        )
+        if result.returncode != 0:
+            error_message = result.stderr.strip() or result.stdout.strip() or "DuckDB CLI command failed."
+            raise RuntimeError(error_message)
+
+        # Parse JSON output and return
+        return json.loads(result.stdout.strip())
+
+
+def _build_duckdb_secret_statements(token: str | bool | None) -> list[str]:
+    if token is None or token is True:
+        token = get_token()
+
+    if not token:
+        return []
+
+    escaped_token = token.replace("'", "''")
+    escaped_endpoint = constants.ENDPOINT.replace("'", "''")
+    return [
+        f"CREATE OR REPLACE SECRET hf_hub_token (TYPE HTTP, BEARER_TOKEN '{escaped_token}', SCOPE '{escaped_endpoint}')",
+        f"CREATE OR REPLACE SECRET hf_token (TYPE HUGGINGFACE, TOKEN '{escaped_token}')",
+    ]
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_eval_results.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_eval_results.py
new file mode 100644
index 0000000000000000000000000000000000000000..6df2a18de2d24cbd80a5c05d2a711897742c26fe
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_eval_results.py
@@ -0,0 +1,219 @@
+"""Evaluation results utilities for the `.eval_results/*.yaml` format.
+
+See https://huggingface.co/docs/hub/eval-results for more details.
+Specifications are available at https://github.com/huggingface/hub-docs/blob/main/eval_results.yaml.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+from .utils import logging
+
+
+logger = logging.get_logger(__name__)
+
+
+@dataclass
+class EvalResultEntry:
+    """
+    Evaluation result entry for the `.eval_results/*.yaml` format.
+
+    Represents evaluation scores stored in model repos that automatically appear on
+    the model page and the benchmark dataset's leaderboard.
+
+    For the legacy `model-index` format in `README.md`, use [`EvalResult`] instead.
+
+    See https://huggingface.co/docs/hub/eval-results for more details.
+
+    Args:
+        dataset_id (`str`):
+            Benchmark dataset ID from the Hub. Example: "cais/hle", "Idavidrein/gpqa".
+        task_id (`str`):
+            Task identifier within the benchmark. Example: "gpqa_diamond".
+        value (`Any`):
+            The metric value. Example: 20.90.
+        dataset_revision (`str`, *optional*):
+            Git SHA of the benchmark dataset.
+        verify_token (`str`, *optional*):
+            A signature that can be used to prove that evaluation is provably auditable and reproducible.
+        date (`str`, *optional*):
+            When the evaluation was run (ISO-8601 datetime). Defaults to git commit time.
+        source_url (`str`, *optional*):
+            Link to the evaluation source (e.g., https://huggingface.co/spaces/SaylorTwift/smollm3-mmlu-pro). Required if `source_name`, `source_user`, or `source_org` is provided.
+        source_name (`str`, *optional*):
+            Display name for the source. Example: "Eval Logs".
+        source_user (`str`, *optional*):
+            HF user name for attribution. Example: "celinah".
+        source_org (`str`, *optional*):
+            HF org name for attribution. Example: "cais".
+        notes (`str`, *optional*):
+            Details about the evaluation setup. Example: "tools", "no-tools", "chain-of-thought".
+
+    Example:
+        ```python
+        >>> from huggingface_hub import EvalResultEntry
+        >>> # Minimal example with required fields only
+        >>> result = EvalResultEntry(
+        ...     dataset_id="Idavidrein/gpqa",
+        ...     task_id="gpqa_diamond",
+        ...     value=0.412,
+        ... )
+        >>> # Full example with all fields
+        >>> result = EvalResultEntry(
+        ...     dataset_id="cais/hle",
+        ...     task_id="default",
+        ...     value=20.90,
+        ...     dataset_revision="5503434ddd753f426f4b38109466949a1217c2bb",
+        ...     verify_token="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+        ...     date="2025-01-15T10:30:00Z",
+        ...     source_url="https://huggingface.co/datasets/cais/hle",
+        ...     source_name="CAIS HLE",
+        ...     source_org="cais",
+        ...     notes="no-tools",
+        ... )
+
+        ```
+    """
+
+    dataset_id: str
+    task_id: str
+    value: Any
+    dataset_revision: str | None = None
+    verify_token: str | None = None
+    date: str | None = None
+    source_url: str | None = None
+    source_name: str | None = None
+    source_user: str | None = None
+    source_org: str | None = None
+    notes: str | None = None
+
+    def __post_init__(self) -> None:
+        if (
+            self.source_name is not None or self.source_user is not None or self.source_org is not None
+        ) and self.source_url is None:
+            raise ValueError(
+                "If `source_name`, `source_user`, or `source_org` is provided, `source_url` must also be provided."
+            )
+
+
+def eval_result_entries_to_yaml(entries: list[EvalResultEntry]) -> list[dict[str, Any]]:
+    """Convert a list of [`EvalResultEntry`] objects to a YAML-serializable list of dicts.
+
+    This produces the format expected in `.eval_results/*.yaml` files.
+
+    Args:
+        entries (`list[EvalResultEntry]`):
+            List of evaluation result entries to serialize.
+
+    Returns:
+        `list[dict[str, Any]]`: A list of dictionaries ready to be dumped to YAML.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import EvalResultEntry, eval_result_entries_to_yaml
+        >>> entries = [
+        ...     EvalResultEntry(dataset_id="cais/hle", task_id="default", value=20.90),
+        ...     EvalResultEntry(dataset_id="Idavidrein/gpqa", task_id="gpqa_diamond", value=0.412),
+        ... ]
+        >>> yaml_data = eval_result_entries_to_yaml(entries)
+        >>> yaml_data[0]
+        {'dataset': {'id': 'cais/hle', 'task_id': 'default'}, 'value': 20.9}
+
+        ```
+
+        To upload eval results to the Hub:
+        ```python
+        >>> import yaml
+        >>> from huggingface_hub import upload_file, EvalResultEntry, eval_result_entries_to_yaml
+        >>> entries = [
+        ...     EvalResultEntry(dataset_id="cais/hle", task_id="default", value=20.90),
+        ... ]
+        >>> yaml_content = yaml.dump(eval_result_entries_to_yaml(entries))
+        >>> upload_file(
+        ...     path_or_fileobj=yaml_content.encode(),
+        ...     path_in_repo=".eval_results/hle.yaml",
+        ...     repo_id="your-username/your-model",
+        ... )
+
+        ```
+    """
+    result = []
+    for entry in entries:
+        # build the dataset object
+        dataset: dict[str, Any] = {"id": entry.dataset_id, "task_id": entry.task_id}
+        if entry.dataset_revision is not None:
+            dataset["revision"] = entry.dataset_revision
+
+        data: dict[str, Any] = {"dataset": dataset, "value": entry.value}
+        if entry.verify_token is not None:
+            data["verifyToken"] = entry.verify_token
+        if entry.date is not None:
+            data["date"] = entry.date
+        # build the source object
+        if entry.source_url is not None:
+            source: dict[str, Any] = {"url": entry.source_url}
+            if entry.source_name is not None:
+                source["name"] = entry.source_name
+            if entry.source_user is not None:
+                source["user"] = entry.source_user
+            if entry.source_org is not None:
+                source["org"] = entry.source_org
+            data["source"] = source
+        if entry.notes is not None:
+            data["notes"] = entry.notes
+
+        result.append(data)
+    return result
+
+
+def parse_eval_result_entries(data: list[dict[str, Any]]) -> list[EvalResultEntry]:
+    """Parse a list of dicts into [`EvalResultEntry`] objects.
+
+    This parses the `.eval_results/*.yaml` format. For the legacy `model-index` format,
+    use [`model_index_to_eval_results`] instead.
+
+    Args:
+        data (`list[dict[str, Any]]`):
+            A list of dictionaries (e.g., parsed from YAML or API response).
+
+    Returns:
+        `list[EvalResultEntry]`: A list of evaluation result entry objects.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import parse_eval_result_entries
+        >>> data = [
+        ...     {"dataset": {"id": "cais/hle", "task_id": "default"}, "value": 20.90},
+        ...     {"dataset": {"id": "Idavidrein/gpqa", "task_id": "gpqa_diamond"}, "value": 0.412},
+        ... ]
+        >>> entries = parse_eval_result_entries(data)
+        >>> entries[0].dataset_id
+        'cais/hle'
+        >>> entries[0].value
+        20.9
+
+        ```
+    """
+    entries = []
+    for item in data:
+        if "error" in item:  # file failed server-side validation
+            logger.warning(f"Skipping invalid eval results file '{item.get('filename')}': {item['error']}")
+            continue
+        entry_data = item.get("data", item)
+        dataset = entry_data.get("dataset", {})
+        source = entry_data.get("source", {})
+        entry = EvalResultEntry(
+            dataset_id=dataset["id"],
+            value=entry_data["value"],
+            task_id=dataset["task_id"],
+            dataset_revision=dataset.get("revision"),
+            verify_token=entry_data.get("verifyToken"),
+            date=entry_data.get("date"),
+            source_url=source.get("url") if source else None,
+            source_name=source.get("name") if source else None,
+            source_user=source.get("user") if source else None,
+            source_org=source.get("org") if source else None,
+            notes=entry_data.get("notes"),
+        )
+        entries.append(entry)
+    return entries
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..ef08599ad40fcb6d55fac1c397597f68b8b52084
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__init__.py
@@ -0,0 +1,13 @@
+# Copyright 2026 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.
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..58452db495b52b3679f6879af80359b82217a0cf
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/client.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/client.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3db12364a7b37fd1cb2007de1abe8426127a7027
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/client.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/sse_client.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/sse_client.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fe6d9bee0b2fa3c8c5d5f01b8cc426b59457d435
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/sse_client.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/types.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e1406783ee416be0e50090bd54499a3b08ffbd01
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/__pycache__/types.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/client.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/client.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ffa92a973ae65cad29d3a5397f74fd81731bfcc
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/client.py
@@ -0,0 +1,130 @@
+# Copyright 2026 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.
+
+
+import json
+import time
+from collections import deque
+from collections.abc import Iterator
+from typing import Literal, TypedDict
+
+import httpx2
+
+from ..utils._headers import build_hf_headers
+from ..utils._http import hf_raise_for_status
+from .sse_client import SSEClient
+from .types import ApiGetReloadEventSourceData, ApiGetReloadRequest
+
+
+HOT_RELOADING_PORT = 7887
+CLIENT_TIMEOUT = 20
+
+
+class MultiReplicaStreamWarning(TypedDict):
+    kind: Literal["warning"]
+    message: str
+
+
+class MultiReplicaStreamEvent(TypedDict):
+    kind: Literal["event"]
+    event: ApiGetReloadEventSourceData
+
+
+class MultiReplicaStreamReplicaHash(TypedDict):
+    kind: Literal["replicaHash"]
+    hash: str
+
+
+class MultiReplicaStreamFullMatch(TypedDict):
+    kind: Literal["fullMatch"]
+
+
+class ReloadClient:
+    def __init__(
+        self,
+        *,
+        host: str,
+        subdomain: str,
+        replica_hash: str,
+        token: str | None,
+    ):
+        base_host = host.replace(subdomain, f"{subdomain}--{HOT_RELOADING_PORT}")
+        self.replica_hash = replica_hash
+        self.client = httpx2.Client(
+            base_url=f"{base_host}/--replicas/+{replica_hash}",
+            headers=build_hf_headers(token=token),
+            timeout=CLIENT_TIMEOUT,
+        )
+
+    def get_reload(self, reload_id: str) -> Iterator[ApiGetReloadEventSourceData] | int:
+        req = ApiGetReloadRequest(reloadId=reload_id)
+        with self.client.stream("POST", "/get-reload", json=req) as res:
+            if res.status_code != 200:
+                return res.status_code
+            hf_raise_for_status(res)
+            for event in SSEClient(res.iter_bytes()).events():
+                if event.event == "message":
+                    yield json.loads(event.data)
+        return None
+
+
+def multi_replica_reload_events(
+    commit_sha: str,
+    host: str,
+    subdomain: str,
+    replica_hashes: list[str],
+    token: str | None,
+    max_retries: int = 10,
+) -> Iterator[
+    MultiReplicaStreamWarning | MultiReplicaStreamEvent | MultiReplicaStreamReplicaHash | MultiReplicaStreamFullMatch
+]:
+    clients = [
+        ReloadClient(
+            host=host,
+            subdomain=subdomain,
+            replica_hash=hash,
+            token=token,
+        )
+        for hash in replica_hashes
+    ]
+
+    first_client_events: dict[int, ApiGetReloadEventSourceData] = {}
+    for client_index, client in enumerate(clients):
+        if len(clients) > 1:
+            yield {"kind": "replicaHash", "hash": client.replica_hash}
+
+        retries = 0
+        while isinstance((events := client.get_reload(commit_sha)), int):
+            if (retries := retries + 1) > max_retries:
+                raise Exception("Too many retries reached")
+            if (status_code := events) not in (200, 204):
+                raise Exception(f"Unexpected {status_code=} on `ReloadClient.get_reload`")
+            subject = "reloadId" if status_code == 204 else "replica"
+            yield {"kind": "warning", "message": f"Retrying on unexpected {subject} not found"}
+            time.sleep(2)
+
+        full_match = True
+        replay: deque[ApiGetReloadEventSourceData] = deque()
+        for event_index, event in enumerate(events):
+            if client_index == 0:
+                first_client_events[event_index] = event
+            elif full_match := full_match and first_client_events.get(event_index) == event:
+                replay.append(event)
+                continue
+            while replay:
+                yield {"kind": "event", "event": replay.popleft()}
+            yield {"kind": "event", "event": event}
+
+        if client_index > 0 and full_match:
+            yield {"kind": "fullMatch"}
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/sse_client.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/sse_client.py
new file mode 100644
index 0000000000000000000000000000000000000000..2dab959bbd62045adff1d8d51438acd5bd062265
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/sse_client.py
@@ -0,0 +1,144 @@
+"""
+Vendored file: Server Side Events (SSE) client for Python.
+
+Source:
+- Author: Maxime Petazzoni <maxime.petazzoni@bulix.org>
+- Repository: https://github.com/mpetazzoni/sseclient
+- File: https://github.com/mpetazzoni/sseclient/blob/main/sseclient/__init__.py
+
+License:
+- Apache-2.0 (from upstream project)
+
+Provides a generator of SSE received through an existing HTTP response.
+"""
+
+import logging
+
+__author__ = 'Maxime Petazzoni <maxime.petazzoni@bulix.org>'
+__email__ = 'maxime.petazzoni@bulix.org'
+__all__ = ['SSEClient']
+
+_FIELD_SEPARATOR = ':'
+
+
+class SSEClient:
+    """Implementation of a SSE client.
+
+    See http://www.w3.org/TR/2009/WD-eventsource-20091029/ for the
+    specification.
+    """
+
+    def __init__(self, event_source, char_enc='utf-8'):
+        """Initialize the SSE client over an existing, ready to consume
+        event source.
+
+        The event source is expected to be a binary stream and have a close()
+        method. That would usually be something that implements
+        io.BinaryIOBase, like an httplib or urllib3 HTTPResponse object.
+        """
+        self._logger = logging.getLogger(self.__class__.__module__)
+        self._logger.debug('Initialized SSE client from event source %s',
+                           event_source)
+        self._event_source = event_source
+        self._char_enc = char_enc
+
+    def _read(self):
+        """Read the incoming event source stream and yield event chunks.
+
+        Unfortunately it is possible for some servers to decide to break an
+        event into multiple HTTP chunks in the response. It is thus necessary
+        to correctly stitch together consecutive response chunks and find the
+        SSE delimiter (empty new line) to yield full, correct event chunks."""
+        data = b''
+        for chunk in self._event_source:
+            for line in chunk.splitlines(True):
+                data += line
+                if data.endswith((b'\r\r', b'\n\n', b'\r\n\r\n')):
+                    yield data
+                    data = b''
+        if data:
+            yield data
+
+    def events(self):
+        for chunk in self._read():
+            event = Event()
+            # Split before decoding so splitlines() only uses \r and \n
+            for line in chunk.splitlines():
+                # Decode the line.
+                line = line.decode(self._char_enc)
+
+                # Lines starting with a separator are comments and are to be
+                # ignored.
+                if not line.strip() or line.startswith(_FIELD_SEPARATOR):
+                    continue
+
+                data = line.split(_FIELD_SEPARATOR, 1)
+                field = data[0]
+
+                # Ignore unknown fields.
+                if field not in event.__dict__:
+                    self._logger.debug('Saw invalid field %s while parsing '
+                                       'Server Side Event', field)
+                    continue
+
+                if len(data) > 1:
+                    # From the spec:
+                    # "If value starts with a single U+0020 SPACE character,
+                    # remove it from value."
+                    if data[1].startswith(' '):
+                        value = data[1][1:]
+                    else:
+                        value = data[1]
+                else:
+                    # If no value is present after the separator,
+                    # assume an empty value.
+                    value = ''
+
+                # The data field may come over multiple lines and their values
+                # are concatenated with each other.
+                if field == 'data':
+                    event.__dict__[field] += value + '\n'
+                else:
+                    event.__dict__[field] = value
+
+            # Events with no data are not dispatched.
+            if not event.data:
+                continue
+
+            # If the data field ends with a newline, remove it.
+            if event.data.endswith('\n'):
+                event.data = event.data[0:-1]
+
+            # Empty event names default to 'message'
+            event.event = event.event or 'message'
+
+            # Dispatch the event
+            self._logger.debug('Dispatching %s...', event)
+            yield event
+
+    def close(self):
+        """Manually close the event source stream."""
+        self._event_source.close()
+
+
+class Event:
+    """Representation of an event from the event stream."""
+
+    def __init__(self, id=None, event='message', data='', retry=None):
+        self.id = id
+        self.event = event
+        self.data = data
+        self.retry = retry
+
+    def __str__(self):
+        s = f'{self.event} event'
+        if self.id:
+            s += f' #{self.id}'
+        if self.data:
+            s += ', {} byte{}'.format(len(self.data),
+                                        's' if len(self.data) else '')
+        else:
+            s += ', no data'
+        if self.retry:
+            s += f', retry in {self.retry}ms'
+        return s
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/types.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/types.py
new file mode 100644
index 0000000000000000000000000000000000000000..c5f892d6287f5b581edca8fdf64c1827e114621b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_hot_reload/types.py
@@ -0,0 +1,121 @@
+# Copyright 2026 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.
+
+
+from typing import Literal, TypedDict
+
+from typing_extensions import NotRequired
+
+
+class ReloadRegion(TypedDict):
+    startLine: int
+    startCol: int
+    endLine: int
+    endCol: int
+
+
+class ReloadOperationObject(TypedDict):
+    kind: Literal["add", "update", "delete"]
+    region: ReloadRegion
+    objectType: str
+    objectName: str
+
+
+class ReloadOperationRun(TypedDict):
+    kind: Literal["run"]
+    region: ReloadRegion
+    codeLines: str
+    stdout: NotRequired[str]
+    stderr: NotRequired[str]
+
+
+class ReloadOperationException(TypedDict):
+    kind: Literal["exception"]
+    region: ReloadRegion
+    traceback: str
+
+
+class ReloadOperationError(TypedDict):
+    kind: Literal["error"]
+    traceback: str
+
+
+class ReloadOperationUI(TypedDict):
+    kind: Literal["ui"]
+    updated: bool
+
+
+class ReloadOperationFile(TypedDict):
+    kind: Literal["file"]
+    created: bool
+
+
+class ApiCreateReloadRequest(TypedDict):
+    filepath: str
+    contents: str
+    reloadId: NotRequired[str]
+
+
+class ApiCreateReloadResponseSuccess(TypedDict):
+    status: Literal["created"]
+    reloadId: str
+
+
+class ApiCreateReloadResponseError(TypedDict):
+    status: Literal["alreadyReloading", "fileNotFound"]
+
+
+class ApiCreateReloadResponse(TypedDict):
+    res: ApiCreateReloadResponseError | ApiCreateReloadResponseSuccess
+
+
+class ApiGetReloadRequest(TypedDict):
+    reloadId: str
+
+
+class ApiGetReloadEventSourceData(TypedDict):
+    data: (
+        ReloadOperationError
+        | ReloadOperationException
+        | ReloadOperationObject
+        | ReloadOperationRun
+        | ReloadOperationUI
+        | ReloadOperationFile
+    )
+
+
+class ApiGetStatusRequest(TypedDict):
+    revision: str
+
+
+class ApiGetStatusResponse(TypedDict):
+    reloading: bool
+    uncommited: list[str]
+
+
+class ApiFetchContentsRequest(TypedDict):
+    filepath: str
+
+
+class ApiFetchContentsResponseError(TypedDict):
+    status: Literal["fileNotFound"]
+
+
+class ApiFetchContentsResponseSuccess(TypedDict):
+    status: Literal["ok"]
+    contents: str
+
+
+class ApiFetchContentsResponse(TypedDict):
+    res: ApiFetchContentsResponseError | ApiFetchContentsResponseSuccess
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py
new file mode 100644
index 0000000000000000000000000000000000000000..9da790ca955ba8b347e323737d695d8f635159c9
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_inference_endpoints.py
@@ -0,0 +1,695 @@
+import time
+import warnings
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import TYPE_CHECKING, Optional
+
+from huggingface_hub.errors import InferenceEndpointError, InferenceEndpointTimeoutError
+
+from .utils import get_session, logging, parse_datetime
+from .utils._headers import get_token_to_send
+
+
+if TYPE_CHECKING:
+    from .hf_api import HfApi
+    from .inference._client import InferenceClient
+    from .inference._generated._async_client import AsyncInferenceClient
+
+logger = logging.get_logger(__name__)
+
+
+def _build_endpoint_image_payload(
+    custom_image: dict,
+    *,
+    container_registry_username: str | None = None,
+    container_registry_password: str | None = None,
+) -> dict:
+    """Build the `model.image` payload of an Inference Endpoint from a user-provided image dict.
+
+    `model.image` is a union keyed by variant (`{"vLLM": {...}}`, `{"custom": {...}}`, ...). Only a flat
+    container dict has a top-level `url` (required server-side, and no variant is named `url`), so dicts with
+    one are wrapped in `{"custom": ...}`. Everything else is forwarded as-is, so variants added to the API
+    later work without a release.
+    """
+    image = {"custom": custom_image} if "url" in custom_image else custom_image
+
+    if container_registry_password is not None and container_registry_username is None:
+        raise ValueError("`container_registry_password` requires `container_registry_username`.")
+    if container_registry_username is None:
+        return image
+
+    custom_container = image.get("custom")
+    if not isinstance(custom_container, dict):
+        raise ValueError("Container registry credentials can only be set for a custom container image.")
+
+    credentials = {"username": container_registry_username}
+    if container_registry_password is not None:
+        credentials["password"] = container_registry_password
+    return {**image, "custom": {**custom_container, "credentials": credentials}}
+
+
+# Image variants that declare `tensorParallelSize` / `dataParallelSize`. The API ignores a field a variant doesn't
+# declare instead of rejecting it, so these only drive a warning: a wrong engine gets a visible no-op rather than a
+# silent one, and an engine the API adds later still works without a `huggingface_hub` release.
+_TENSOR_PARALLEL_IMAGE_KEYS = ("sGLang", "vLLM")
+_DATA_PARALLEL_IMAGE_KEYS = ("vLLM",)
+
+
+def _set_parallelism_in_image(
+    image: dict,
+    *,
+    tensor_parallel_size: int | None = None,
+    data_parallel_size: int | None = None,
+) -> dict:
+    """Write the parallelism sizes into a `model.image` payload.
+
+    They are engine settings, so they live inside the engine config (`{"vLLM": {"url": ..., "tensorParallelSize": 8}}`)
+    rather than at the top level. Returns a new image dict, the input is left untouched.
+    """
+    image_key = next(iter(image), None)
+    if image_key is None:
+        raise ValueError("Cannot set the parallelism sizes: the image payload is empty.")
+
+    for value, name, supported in (
+        (tensor_parallel_size, "tensor_parallel_size", _TENSOR_PARALLEL_IMAGE_KEYS),
+        (data_parallel_size, "data_parallel_size", _DATA_PARALLEL_IMAGE_KEYS),
+    ):
+        if value is not None and image_key not in supported:
+            warnings.warn(
+                f"`{name}` is not a known setting of the '{image_key}' image: the API will silently drop it."
+                f" Engines that support it: {', '.join(supported)}.",
+                UserWarning,
+            )
+
+    image = {image_key: {**image[image_key]}}
+    if tensor_parallel_size is not None:
+        image[image_key]["tensorParallelSize"] = tensor_parallel_size
+    if data_parallel_size is not None:
+        image[image_key]["dataParallelSize"] = data_parallel_size
+    return image
+
+
+class InferenceEndpointStatus(str, Enum):
+    PENDING = "pending"
+    INITIALIZING = "initializing"
+    UPDATING = "updating"
+    UPDATE_FAILED = "updateFailed"
+    RUNNING = "running"
+    PAUSED = "paused"
+    FAILED = "failed"
+    SCALED_TO_ZERO = "scaledToZero"
+
+
+class InferenceEndpointType(str, Enum):
+    PUBlIC = "public"
+    AUTHENTICATED = "authenticated"
+    PRIVATE = "private"
+
+
+class InferenceEndpointScalingMetric(str, Enum):
+    PENDING_REQUESTS = "pendingRequests"
+    HARDWARE_USAGE = "hardwareUsage"
+
+
+@dataclass
+class InferenceEndpoint:
+    """
+    Contains information about a deployed Inference Endpoint.
+
+    Args:
+        name (`str`):
+            The unique name of the Inference Endpoint.
+        namespace (`str`):
+            The namespace where the Inference Endpoint is located.
+        repository (`str`):
+            The name of the model repository deployed on this Inference Endpoint.
+        status ([`InferenceEndpointStatus`]):
+            The current status of the Inference Endpoint.
+        url (`str`, *optional*):
+            The URL of the Inference Endpoint, if available. Only a deployed Inference Endpoint will have a URL.
+        framework (`str`):
+            The machine learning framework used for the model.
+        revision (`str`):
+            The specific model revision deployed on the Inference Endpoint.
+        task (`str`):
+            The task associated with the deployed model.
+        created_at (`datetime.datetime`):
+            The timestamp when the Inference Endpoint was created.
+        updated_at (`datetime.datetime`):
+            The timestamp of the last update of the Inference Endpoint.
+        type ([`InferenceEndpointType`]):
+            The type of the Inference Endpoint (public, authenticated, private).
+        raw (`dict`):
+            The raw dictionary data returned from the API.
+        token (`str` or `bool`, *optional*):
+            Authentication token for the Inference Endpoint, if set when requesting the API. Will default to the
+            locally saved token if not provided. Pass `token=False` if you don't want to send your token to the server.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import get_inference_endpoint
+        >>> endpoint = get_inference_endpoint("my-text-to-image")
+        >>> endpoint
+        InferenceEndpoint(name='my-text-to-image', ...)
+
+        # Get status
+        >>> endpoint.status
+        'running'
+        >>> endpoint.url
+        'https://68a0f3b5c6ee5c9dcc0e0a01.endpoints.huggingface.cloud'
+
+        # Run inference
+        >>> endpoint.client.text_to_image(...)
+
+        # Pause endpoint to save $$$
+        >>> endpoint.pause()
+
+        # ...
+        # Resume and wait for deployment
+        >>> endpoint.resume()
+        >>> endpoint.wait()
+        >>> endpoint.client.text_to_image(...)
+        ```
+    """
+
+    # Field in __repr__
+    name: str = field(init=False)
+    namespace: str
+    repository: str = field(init=False)
+    status: InferenceEndpointStatus = field(init=False)
+    health_route: str = field(init=False)
+    url: str | None = field(init=False)
+
+    # Other fields
+    framework: str = field(repr=False, init=False)
+    revision: str = field(repr=False, init=False)
+    task: str = field(repr=False, init=False)
+    created_at: datetime = field(repr=False, init=False)
+    updated_at: datetime = field(repr=False, init=False)
+    type: InferenceEndpointType = field(repr=False, init=False)
+
+    # Raw dict from the API
+    raw: dict = field(repr=False)
+
+    # Internal fields
+    _token: str | bool | None = field(repr=False, compare=False)
+    _api: "HfApi" = field(repr=False, compare=False)
+
+    @classmethod
+    def from_raw(
+        cls, raw: dict, namespace: str, token: str | bool | None = None, api: Optional["HfApi"] = None
+    ) -> "InferenceEndpoint":
+        """Initialize object from raw dictionary."""
+        if api is None:
+            from .hf_api import HfApi
+
+            api = HfApi()
+        if token is None:
+            token = api.token
+        if token is True:
+            token = get_token_to_send(token)
+
+        # All other fields are populated in __post_init__
+        return cls(raw=raw, namespace=namespace, _token=token, _api=api)
+
+    def __post_init__(self) -> None:
+        """Populate fields from raw dictionary."""
+        self._populate_from_raw()
+
+    @property
+    def client(self) -> "InferenceClient":
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`InferenceClient`]: an inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        from .inference._client import InferenceClient
+
+        return InferenceClient(
+            model=self.url,
+            token=self._token,  # type: ignore # boolean token shouldn't be possible. In practice it's ok.
+        )
+
+    @property
+    def async_client(self) -> "AsyncInferenceClient":
+        """Returns a client to make predictions on this Inference Endpoint.
+
+        Returns:
+            [`AsyncInferenceClient`]: an asyncio-compatible inference client pointing to the deployed endpoint.
+
+        Raises:
+            [`InferenceEndpointError`]: If the Inference Endpoint is not yet deployed.
+        """
+        if self.url is None:
+            raise InferenceEndpointError(
+                "Cannot create a client for this Inference Endpoint as it is not yet deployed. "
+                "Please wait for the Inference Endpoint to be deployed using `endpoint.wait()` and try again."
+            )
+        from .inference._generated._async_client import AsyncInferenceClient
+
+        return AsyncInferenceClient(
+            model=self.url,
+            token=self._token,  # type: ignore # boolean token shouldn't be possible. In practice it's ok.
+        )
+
+    def wait(self, timeout: int | None = None, refresh_every: int = 5) -> "InferenceEndpoint":
+        """Wait for the Inference Endpoint to be deployed.
+
+        Information from the server will be fetched every 1s. If the Inference Endpoint is not deployed after `timeout`
+        seconds, a [`InferenceEndpointTimeoutError`] will be raised. The [`InferenceEndpoint`] will be mutated in place with the latest
+        data.
+
+        Args:
+            timeout (`int`, *optional*):
+                The maximum time to wait for the Inference Endpoint to be deployed, in seconds. If `None`, will wait
+                indefinitely.
+            refresh_every (`int`, *optional*):
+                The time to wait between each fetch of the Inference Endpoint status, in seconds. Defaults to 5s.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+
+        Raises:
+            [`InferenceEndpointError`]
+                If the Inference Endpoint ended up in a failed state.
+            [`InferenceEndpointTimeoutError`]
+                If the Inference Endpoint is not deployed after `timeout` seconds.
+        """
+        if timeout is not None and timeout < 0:
+            raise ValueError("`timeout` cannot be negative.")
+        if refresh_every <= 0:
+            raise ValueError("`refresh_every` must be positive.")
+
+        start = time.time()
+        while True:
+            if self.status == InferenceEndpointStatus.FAILED:
+                raise InferenceEndpointError(
+                    f"Inference Endpoint {self.name} failed to deploy. Please check the logs for more information."
+                )
+            if self.status == InferenceEndpointStatus.UPDATE_FAILED:
+                raise InferenceEndpointError(
+                    f"Inference Endpoint {self.name} failed to update. Please check the logs for more information."
+                )
+            if self.status == InferenceEndpointStatus.RUNNING and self.url is not None:
+                # Verify the endpoint is actually reachable
+                _health_url = f"{self.url.rstrip('/')}/{self.health_route.lstrip('/')}"
+                response = get_session().get(_health_url, headers=self._api._build_hf_headers(token=self._token))
+                if response.status_code == 200:
+                    logger.info("Inference Endpoint is ready to be used.")
+                    return self
+
+            if timeout is not None:
+                if time.time() - start > timeout:
+                    raise InferenceEndpointTimeoutError("Timeout while waiting for Inference Endpoint to be deployed.")
+            logger.info(f"Inference Endpoint is not deployed yet ({self.status}). Waiting {refresh_every}s...")
+            time.sleep(refresh_every)
+            self.fetch()
+
+    def fetch(self) -> "InferenceEndpoint":
+        """Fetch latest information about the Inference Endpoint.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.get_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def update(
+        self,
+        *,
+        # Compute update
+        accelerator: str | None = None,
+        instance_size: str | None = None,
+        instance_type: str | None = None,
+        min_replica: int | None = None,
+        max_replica: int | None = None,
+        scale_to_zero_timeout: int | None = None,
+        # Model update
+        repository: str | None = None,
+        framework: str | None = None,
+        revision: str | None = None,
+        task: str | None = None,
+        custom_image: dict | None = None,
+        container_command: list[str] | None = None,
+        container_args: list[str] | None = None,
+        tensor_parallel_size: int | None = None,
+        data_parallel_size: int | None = None,
+        secrets: dict[str, str] | None = None,
+    ) -> "InferenceEndpoint":
+        """Update the Inference Endpoint.
+
+        This method allows the update of either the compute configuration, the deployed model, or both. All arguments are
+        optional but at least one must be provided.
+
+        This is an alias for [`HfApi.update_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Args:
+            accelerator (`str`, *optional*):
+                The hardware accelerator to be used for inference (e.g. `"cpu"`).
+            instance_size (`str`, *optional*):
+                The size or type of the instance to be used for hosting the model (e.g. `"x4"`).
+            instance_type (`str`, *optional*):
+                The cloud instance type where the Inference Endpoint will be deployed (e.g. `"intel-icl"`).
+            min_replica (`int`, *optional*):
+                The minimum number of replicas (instances) to keep running for the Inference Endpoint.
+            max_replica (`int`, *optional*):
+                The maximum number of replicas (instances) to scale to for the Inference Endpoint.
+            scale_to_zero_timeout (`int`, *optional*):
+                The duration in minutes before an inactive endpoint is scaled to zero.
+
+            repository (`str`, *optional*):
+                The name of the model repository associated with the Inference Endpoint (e.g. `"gpt2"`).
+            framework (`str`, *optional*):
+                The machine learning framework used for the model (e.g. `"custom"`).
+            revision (`str`, *optional*):
+                The specific model revision to deploy on the Inference Endpoint (e.g. `"6c0e6080953db56375760c0471a8c5f2929baf11"`).
+            task (`str`, *optional*):
+                The task on which to deploy the model (e.g. `"text-classification"`).
+            custom_image (`dict`, *optional*):
+                The container image to run. Either a dict keyed by image variant (e.g.
+                `{"vLLM": {"url": "vllm/vllm-openai:v0.23.0", "port": 8000}}`, also `sGLang`, `tgi`, `tei`,
+                `llamacpp`, `hfServe`, ...), which is forwarded as-is, or a flat dict describing a custom
+                container (e.g. `{"url": ..., "port": ...}`), which is sent as `{"custom": ...}`.
+            container_command (`list[str]`, *optional*):
+                Override the container entrypoint command (maps to `model.command` in the API payload). Works with
+                both managed engine images (e.g. vLLM, SGLang) and custom images.
+            container_args (`list[str]`, *optional*):
+                Arguments appended to the container entrypoint (maps to `model.args` in the API payload). Works with
+                both managed engine images (e.g. vLLM, SGLang) and custom images.
+            tensor_parallel_size (`int`, *optional*):
+                Number of accelerators to shard a single model copy across (vLLM and SGLang images). When
+                `custom_image` is not given, the image currently configured on the endpoint is fetched and updated
+                in place, as the API requires `model.image` as a whole.
+            data_parallel_size (`int`, *optional*):
+                Number of model copies to run, one per accelerator (vLLM images).
+            secrets (`dict[str, str]`, *optional*):
+                Secret values to inject in the container environment.
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        # Make API call
+        obj = self._api.update_inference_endpoint(
+            name=self.name,
+            namespace=self.namespace,
+            accelerator=accelerator,
+            instance_size=instance_size,
+            instance_type=instance_type,
+            min_replica=min_replica,
+            max_replica=max_replica,
+            scale_to_zero_timeout=scale_to_zero_timeout,
+            repository=repository,
+            framework=framework,
+            revision=revision,
+            task=task,
+            custom_image=custom_image,
+            container_command=container_command,
+            container_args=container_args,
+            tensor_parallel_size=tensor_parallel_size,
+            data_parallel_size=data_parallel_size,
+            secrets=secrets,
+            token=self._token,  # type: ignore [arg-type]
+        )
+
+        # Mutate current object
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def pause(self) -> "InferenceEndpoint":
+        """Pause the Inference Endpoint.
+
+        A paused Inference Endpoint will not be charged. It can be resumed at any time using [`InferenceEndpoint.resume`].
+        This is different from scaling the Inference Endpoint to zero with [`InferenceEndpoint.scale_to_zero`], which
+        would be automatically restarted when a request is made to it.
+
+        This is an alias for [`HfApi.pause_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.pause_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def resume(self, running_ok: bool = True) -> "InferenceEndpoint":
+        """Resume the Inference Endpoint.
+
+        This is an alias for [`HfApi.resume_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Args:
+            running_ok (`bool`, *optional*):
+                If `True`, the method will not raise an error if the Inference Endpoint is already running. Defaults to
+                `True`.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.resume_inference_endpoint(
+            name=self.name, namespace=self.namespace, running_ok=running_ok, token=self._token
+        )  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def scale_to_zero(self) -> "InferenceEndpoint":
+        """Scale Inference Endpoint to zero.
+
+        An Inference Endpoint scaled to zero will not be charged. It will be resumed on the next request to it, with a
+        cold start delay. This is different from pausing the Inference Endpoint with [`InferenceEndpoint.pause`], which
+        would require a manual resume with [`InferenceEndpoint.resume`].
+
+        This is an alias for [`HfApi.scale_to_zero_inference_endpoint`]. The current object is mutated in place with the
+        latest data from the server.
+
+        Returns:
+            [`InferenceEndpoint`]: the same Inference Endpoint, mutated in place with the latest data.
+        """
+        obj = self._api.scale_to_zero_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+        self.raw = obj.raw
+        self._populate_from_raw()
+        return self
+
+    def delete(self) -> None:
+        """Delete the Inference Endpoint.
+
+        This operation is not reversible. If you don't want to be charged for an Inference Endpoint, it is preferable
+        to pause it with [`InferenceEndpoint.pause`] or scale it to zero with [`InferenceEndpoint.scale_to_zero`].
+
+        This is an alias for [`HfApi.delete_inference_endpoint`].
+        """
+        self._api.delete_inference_endpoint(name=self.name, namespace=self.namespace, token=self._token)  # type: ignore [arg-type]
+
+    def _populate_from_raw(self) -> None:
+        """Populate fields from raw dictionary.
+
+        Called in __post_init__ + each time the Inference Endpoint is updated.
+        """
+        # Repr fields
+        self.name = self.raw["name"]
+        self.repository = self.raw["model"]["repository"]
+        self.status = self.raw["status"]["state"]
+        self.url = self.raw["status"].get("url")
+        self.health_route = self.raw["healthRoute"]
+
+        # Other fields
+        self.framework = self.raw["model"]["framework"]
+        self.revision = self.raw["model"]["revision"]
+        self.task = self.raw["model"]["task"]
+        self.created_at = parse_datetime(self.raw["status"]["createdAt"])
+        self.updated_at = parse_datetime(self.raw["status"]["updatedAt"])
+        self.type = self.raw["type"]
+
+
+@dataclass
+class InferenceEndpointHardware:
+    """
+    Contains information about a hardware configuration available for Inference Endpoints.
+
+    The `vendor`, `region`, `accelerator`, `instance_type` and `instance_size` fields are exactly the values to pass to
+    [`create_inference_endpoint`] (or `hf endpoints deploy`) to deploy on this hardware.
+
+    Args:
+        id (`str`):
+            Unique hardware identifier, e.g. `"aws-us-east-1-nvidia-l4-x1"`.
+        vendor (`str`):
+            The cloud provider hosting the hardware, e.g. `"aws"`.
+        region (`str`):
+            The cloud region the hardware is available in, e.g. `"us-east-1"`.
+        accelerator (`str`):
+            The type of hardware accelerator, e.g. `"cpu"`, `"gpu"` or `"neuron"`.
+        instance_type (`str`):
+            The cloud instance type, e.g. `"nvidia-l4"`.
+        instance_size (`str`):
+            The instance size multiplier, e.g. `"x1"`.
+        architecture (`str`):
+            Human-readable hardware description, e.g. `"Nvidia L4"`.
+        num_accelerators (`int`):
+            Number of accelerator units per replica.
+        num_cpus (`int`, *optional*):
+            Number of vCPUs per replica.
+        memory_gb (`float`):
+            RAM per replica, in GB.
+        gpu_memory_gb (`int`, *optional*):
+            Total GPU memory per replica, in GB (i.e. summed over `num_accelerators`). `None` for non-GPU hardware.
+        price_per_hour (`float`):
+            Cost per replica per hour, in USD.
+        status (`str`):
+            Availability of the hardware: `"available"`, `"low_availability"`, `"not_available"`, `"reserved"` or
+            `"deprecated"`.
+        max_accelerators (`int`):
+            Maximum number of accelerators of this type the namespace is allowed to run.
+        used_accelerators (`int`):
+            Number of accelerators of this type currently used by the namespace.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import list_inference_endpoints_hardware
+        >>> hardware = list_inference_endpoints_hardware()
+        >>> hardware[0]
+        InferenceEndpointHardware(id='aws-us-east-1-nvidia-l4-x1', vendor='aws', region='us-east-1', ...)
+        ```
+    """
+
+    id: str
+    vendor: str
+    region: str
+    accelerator: str
+    instance_type: str
+    instance_size: str
+    architecture: str
+    num_accelerators: int
+    num_cpus: int | None
+    memory_gb: float
+    gpu_memory_gb: int | None
+    price_per_hour: float
+    status: str
+    max_accelerators: int
+    used_accelerators: int
+
+    @classmethod
+    def from_raw(cls, raw: dict, *, vendor: str, region: str) -> "InferenceEndpointHardware":
+        """Initialize object from a raw compute dictionary, nested under a vendor and a region in the API response."""
+        quota = raw["quota"]
+        return cls(
+            id=raw["id"],
+            vendor=vendor,
+            region=region,
+            accelerator=raw["accelerator"],
+            instance_type=raw["instanceType"],
+            instance_size=raw["instanceSize"],
+            architecture=raw["architecture"],
+            num_accelerators=raw["numAccelerators"],
+            num_cpus=raw.get("numCpus"),
+            memory_gb=raw["memoryGb"],
+            gpu_memory_gb=raw.get("gpuMemoryGb"),
+            price_per_hour=raw["pricePerHour"],
+            status=raw["status"],
+            max_accelerators=quota["maxAccelerators"],
+            used_accelerators=quota["usedAccelerators"],
+        )
+
+
+@dataclass
+class InferenceCatalogRecipe:
+    """
+    Contains information about a pre-tested way of deploying a model from the Inference Catalog.
+
+    A recipe is a hardware and engine combination that the Inference Endpoints team has tested for a given model. A
+    model usually has one recipe, but it can have several (e.g. a GPU one and a Neuron one, or one per GGUF quant).
+
+    Args:
+        id (`str`):
+            The public recipe id, to pass to [`create_inference_endpoint_from_catalog`] as `recipe_id`.
+        accelerator (`str`):
+            The type of hardware accelerator the recipe runs on, e.g. `"cpu"`, `"gpu"` or `"neuron"`.
+        engine (`str`):
+            The inference engine the recipe runs, e.g. `"vllm"`, `"llamacpp"`, `"tei"` or `"sglang"`.
+        gguf_file (`str`, *optional*):
+            The GGUF file deployed by the recipe. Only set for `"llamacpp"` recipes.
+        revision (`str`, *optional*):
+            The model revision the recipe is pinned to, if any.
+    """
+
+    id: str
+    accelerator: str
+    engine: str
+    gguf_file: str | None
+    revision: str | None
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "InferenceCatalogRecipe":
+        """Initialize object from a raw recipe dictionary, nested under a model in the API response."""
+        return cls(
+            id=raw["publicId"],
+            accelerator=raw["accelerator"],
+            engine=raw["engineType"],
+            gguf_file=raw.get("ggufFile"),
+            revision=raw.get("revision"),
+        )
+
+
+@dataclass
+class InferenceCatalogModel:
+    """
+    Contains information about a model available in the Inference Catalog.
+
+    Args:
+        repo_id (`str`):
+            The id of the model repository on the Hub, e.g. `"meta-llama/Llama-3.1-8B-Instruct"`.
+        name (`str`):
+            The model name, i.e. the part of `repo_id` after the author, e.g. `"Llama-3.1-8B-Instruct"`.
+        author (`str`):
+            The author of the model repository, e.g. `"meta-llama"`.
+        license (`str`):
+            The license of the model, e.g. `"Apache 2.0"`.
+        task (`str`):
+            The task the model is deployed on, e.g. `"text-generation"`.
+        created_at (`datetime`):
+            The date the model was added to the catalog.
+        recipes (`list[InferenceCatalogRecipe]`):
+            The tested ways of deploying this model.
+
+    Example:
+        ```python
+        >>> from huggingface_hub import list_inference_catalog
+        >>> catalog = list_inference_catalog(engine="vllm")
+        >>> catalog[0]
+        InferenceCatalogModel(repo_id='Qwen/Qwen2.5-Coder-7B-Instruct', name='Qwen2.5-Coder-7B-Instruct', ...)
+        ```
+    """
+
+    repo_id: str
+    name: str
+    author: str
+    license: str
+    task: str
+    created_at: datetime
+    recipes: list[InferenceCatalogRecipe]
+
+    @classmethod
+    def from_raw(cls, raw: dict) -> "InferenceCatalogModel":
+        """Initialize object from a raw catalog item dictionary."""
+        return cls(
+            repo_id=raw["repoId"],
+            name=raw["modelName"],
+            author=raw["authorName"],
+            license=raw["license"],
+            task=raw["task"],
+            created_at=parse_datetime(raw["createdAt"]),
+            recipes=[InferenceCatalogRecipe.from_raw(recipe) for recipe in raw["recipes"]],
+        )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_jobs_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_jobs_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..b60e3dc9544477b278a532cc13f4bbb7859fcf22
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_jobs_api.py
@@ -0,0 +1,708 @@
+# Copyright 2025-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import hashlib
+import platform
+import re
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any
+
+from huggingface_hub import constants
+from huggingface_hub._space_api import Volume
+from huggingface_hub.utils._datetime import parse_datetime
+
+
+class JobHardware(str, Enum):
+    """
+    Enumeration of hardware flavors available to run Jobs on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert JobHardware.CPU_BASIC == "cpu-basic"
+    ```
+
+    Both enums are kept in sync with the Hub API by `utils/check_hardware_flavors.py`.
+    """
+
+    # CPU
+    CPU_BASIC = "cpu-basic"
+    CPU_UPGRADE = "cpu-upgrade"
+    CPU_PERFORMANCE = "cpu-performance"
+    CPU_XL = "cpu-xl"
+
+    # GPU
+    T4_SMALL = "t4-small"
+    T4_MEDIUM = "t4-medium"
+    L4X1 = "l4x1"
+    L4X4 = "l4x4"
+    L40SX1 = "l40sx1"
+    L40SX4 = "l40sx4"
+    L40SX8 = "l40sx8"
+    A10G_SMALL = "a10g-small"
+    A10G_LARGE = "a10g-large"
+    A10G_LARGEX2 = "a10g-largex2"
+    A10G_LARGEX4 = "a10g-largex4"
+    A100_LARGE = "a100-large"
+    A100X4 = "a100x4"
+    A100X8 = "a100x8"
+    H200 = "h200"
+    H200X2 = "h200x2"
+    H200X4 = "h200x4"
+    H200X8 = "h200x8"
+    RTX_PRO_6000 = "rtx-pro-6000"
+    RTX_PRO_6000X2 = "rtx-pro-6000x2"
+    RTX_PRO_6000X4 = "rtx-pro-6000x4"
+    RTX_PRO_6000X8 = "rtx-pro-6000x8"
+
+
+class JobStage(str, Enum):
+    """
+    Enumeration of possible stage of a Job on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert JobStage.COMPLETED == "COMPLETED"
+    ```
+    Possible values are: `COMPLETED`, `CANCELED`, `ERROR`, `DELETED`, `SCHEDULING`, `RUNNING`.
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/job_types/JobInfo.ts#L61 (private url).
+    """
+
+    # Copied from moon-landing > server > lib > Job.ts
+    COMPLETED = "COMPLETED"
+    CANCELED = "CANCELED"
+    ERROR = "ERROR"
+    DELETED = "DELETED"
+    SCHEDULING = "SCHEDULING"
+    RUNNING = "RUNNING"
+
+
+# Stages indicating the Job has reached a terminal state and will not run further.
+TERMINAL_JOB_STAGES = (JobStage.COMPLETED, JobStage.CANCELED, JobStage.ERROR, JobStage.DELETED)
+
+# Default image used to run UV scripts: Debian Bookworm with Python 3.12 and `uv` pre-installed.
+DEFAULT_UV_IMAGE = "ghcr.io/astral-sh/uv:python3.12-bookworm"
+
+# URL prefixes identifying an image that points to a HF Space rather than a Docker image.
+_SPACE_IMAGE_PREFIXES = (
+    "https://huggingface.co/spaces/",
+    "https://hf.co/spaces/",
+    "huggingface.co/spaces/",
+    "hf.co/spaces/",
+)
+
+
+@dataclass
+class JobStatus:
+    stage: JobStage
+    message: str | None
+    expose_urls: list[str] | None
+    ssh_url: str | None
+
+
+@dataclass
+class JobOwner:
+    id: str
+    name: str
+    type: str
+
+
+@dataclass
+class JobNetwork:
+    """
+    Network group a Job joined.
+
+    Args:
+        group (`str`):
+            Name of the network group, as passed to `network_group=`.
+        aliases (`list[str]`):
+            Aliases the Job claims in the group, as passed to `network_aliases=`. Empty when none.
+    """
+
+    group: str
+    aliases: list[str]
+
+    def __init__(self, **kwargs) -> None:
+        self.group = kwargs["group"]
+        self.aliases = kwargs.get("aliases") or []
+
+
+@dataclass
+class JobDurations:
+    """
+    Timing breakdown for a Job, computed server-side.
+
+    Args:
+        scheduling_secs (`int` or `None`):
+            Seconds the job spent in the scheduling stage before starting to run.
+            `None` if the job never reached the running stage.
+        running_secs (`int` or `None`):
+            Seconds the job has been or was running. Recomputed on each request
+            while the job is in progress. `None` if the job never started running.
+        total_secs (`int` or `None`):
+            Total seconds elapsed since the job was created. Recomputed on each
+            request while the job is in progress.
+    """
+
+    scheduling_secs: int | None
+    running_secs: int | None
+    total_secs: int | None
+
+    def __init__(self, **kwargs) -> None:
+        self.scheduling_secs = kwargs.get("schedulingSecs", kwargs.get("scheduling_secs"))
+        self.running_secs = kwargs.get("runningSecs", kwargs.get("running_secs"))
+        self.total_secs = kwargs.get("totalSecs", kwargs.get("total_secs"))
+
+
+@dataclass
+class JobInitiator:
+    """
+    Contains information about what triggered a Job.
+
+    Args:
+        type (`str`): Initiator kind, for example `"user"`, `"org"`, `"scheduled-job"`, or `"duplicated-job"`.
+        id (`str`): Identifier of the initiator.
+        name (`str` or `None`): Human-readable name when available, usually for user/org initiators.
+    """
+
+    type: str
+    id: str
+    name: str | None = None
+
+
+@dataclass
+class JobInfo:
+    """
+    Contains information about a Job.
+
+    Args:
+        id (`str`):
+            Job ID.
+        created_at (`datetime` or `None`):
+            When the Job was created.
+        started_at (`datetime` or `None`):
+            When the Job started running. None while the Job is still scheduling.
+        finished_at (`datetime` or `None`):
+            When the Job finished. None while the Job is still scheduling or running.
+        docker_image (`str` or `None`):
+            The Docker image from Docker Hub used for the Job.
+            Can be None if space_id is present instead.
+        space_id (`str` or `None`):
+            The Docker image from Hugging Face Spaces used for the Job.
+            Can be None if docker_image is present instead.
+        command (`list[str]` or `None`):
+            Command of the Job, e.g. `["python", "-c", "print('hello world')"]`
+        arguments (`list[str]` or `None`):
+            Arguments passed to the command
+        environment (`dict[str]` or `None`):
+            Environment variables of the Job as a dictionary.
+        secrets (`dict[str]` or `None`):
+            Secret environment variables of the Job (encrypted).
+        flavor (`str` or `None`):
+            Flavor for the hardware. See [`JobHardware`] for possible values.
+            E.g. `"cpu-basic"`.
+        labels (`dict[str, str]` or `None`):
+            Labels to attach to the job (key-value pairs).
+        volumes (`list[Volume]` or `None`):
+            Volumes mounted in the job container (buckets, models, datasets, spaces).
+        status: (`JobStatus` or `None`):
+            Status of the Job, e.g. `JobStatus(stage="RUNNING", message=None)`
+            See [`JobStage`] for possible stage values.
+        durations (`JobDurations` or `None`):
+            Timing breakdown of the Job. Present for all job states including SCHEDULING.
+        owner: (`JobOwner` or `None`):
+            Owner of the Job, e.g. `JobOwner(id="5e9ecfc04957053f60648a3e", name="lhoestq", type="user")`
+        initiator (`JobInitiator` or `None`):
+            What triggered the Job, e.g. `JobInitiator(type="scheduled-job", id="...")` for a cron-triggered run.
+        expose_urls (`list[str]` or `None`):
+            Public URLs through which the Job's exposed ports are reachable (one per exposed port),
+            e.g. `["https://687fb701029421ae5549d998--8000.hf.jobs"]`. `None` when no port is exposed.
+            Accessing a URL requires an HF token with read access to the Job's namespace, unless the port is public.
+        ssh_url (`str` or `None`):
+            SSH endpoint of the Job, e.g. `"ssh://687fb701029421ae5549d998@ssh.hf.jobs"`. Only present when the Job
+            was started with `ssh=True`. Connecting requires write access to the Job's namespace and an SSH public
+            key registered on the Hub (https://huggingface.co/settings/keys).
+        network (`JobNetwork` or `None`):
+            Network group the Job joined and the aliases it claims, e.g. `JobNetwork(group="train", aliases=["master"])`.
+            `None` when the Job was started without `network_group=`.
+        retry (`int` or `None`):
+            Number of retries configured for the Job (`attempts - 1`).
+        expose (`list[int]` or `None`):
+            All ports exposed through the Jobs proxy, public ones included.
+        expose_public (`list[int]` or `None`):
+            Exposed ports reachable without authentication.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import run_job
+    >>> job = run_job(
+    ...     image="python:3.12",
+    ...     command=["python", "-c", "print('Hello from the cloud!')"]
+    ... )
+    >>> job
+    JobInfo(id='687fb701029421ae5549d998', created_at=datetime.datetime(2025, 7, 22, 16, 6, 25, 79000, tzinfo=datetime.timezone.utc), started_at=datetime.datetime(2025, 7, 22, 16, 6, 31, 79000, tzinfo=datetime.timezone.utc), finished_at=None, docker_image='python:3.12', space_id=None, command=['python', '-c', "print('Hello from the cloud!')"], arguments=[], environment={}, secrets={}, flavor='cpu-basic', labels=None, status=JobStatus(stage='RUNNING', message=None), durations=JobDurations(scheduling_secs=6, running_secs=2, total_secs=8), owner=JobOwner(id='5e9ecfc04957053f60648a3e', name='lhoestq', type='user'), initiator=JobInitiator(type='user', id='5e9ecfc04957053f60648a3e', name='lhoestq'), endpoint='https://huggingface.co', url='https://huggingface.co/jobs/lhoestq/687fb701029421ae5549d998')
+    >>> job.id
+    '687fb701029421ae5549d998'
+    >>> job.url
+    'https://huggingface.co/jobs/lhoestq/687fb701029421ae5549d998'
+    >>> job.status.stage
+    'RUNNING'
+    ```
+    """
+
+    id: str
+    created_at: datetime | None
+    started_at: datetime | None
+    finished_at: datetime | None
+    docker_image: str | None
+    space_id: str | None
+    command: list[str] | None
+    arguments: list[str] | None
+    environment: dict[str, Any] | None
+    secrets: dict[str, Any] | None
+    flavor: JobHardware | None
+    labels: dict[str, str] | None
+    volumes: list[Volume] | None
+    status: JobStatus
+    durations: JobDurations | None
+    owner: JobOwner
+    initiator: JobInitiator | None
+    network: JobNetwork | None
+    retry: int | None
+    expose: list[int] | None
+    expose_public: list[int] | None
+
+    # Inferred fields
+    endpoint: str
+    url: str
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        created_at = kwargs.get("createdAt") or kwargs.get("created_at")
+        self.created_at = parse_datetime(created_at) if created_at else None
+        started_at = kwargs.get("startedAt") or kwargs.get("started_at")
+        self.started_at = parse_datetime(started_at) if started_at else None
+        finished_at = kwargs.get("finishedAt") or kwargs.get("finished_at")
+        self.finished_at = parse_datetime(finished_at) if finished_at else None
+        self.docker_image = kwargs.get("dockerImage") or kwargs.get("docker_image")
+        self.space_id = kwargs.get("spaceId") or kwargs.get("space_id")
+        owner = kwargs.get("owner", {})
+        self.owner = JobOwner(id=owner["id"], name=owner["name"], type=owner["type"])
+        self.command = kwargs.get("command")
+        self.arguments = kwargs.get("arguments")
+        self.environment = kwargs.get("environment")
+        self.secrets = kwargs.get("secrets")
+        self.flavor = kwargs.get("flavor")
+        self.labels = kwargs.get("labels")
+        volumes = kwargs.get("volumes")
+        self.volumes = [Volume(**v) for v in volumes] if volumes else None
+        status = kwargs.get("status", {})
+        self.status = JobStatus(
+            stage=status["stage"],
+            message=status.get("message"),
+            expose_urls=status.get("exposeUrls"),
+            ssh_url=status.get("sshUrl"),
+        )
+        durations = kwargs.get("durations")
+        self.durations = JobDurations(**durations) if durations else None
+        initiator = kwargs.get("initiator")
+        self.initiator = (
+            JobInitiator(type=initiator["type"], id=initiator["id"], name=initiator.get("name")) if initiator else None
+        )
+        network = kwargs.get("network")
+        self.network = JobNetwork(**network) if network else None
+        self.retry = kwargs.get("retry")
+        expose = kwargs.get("expose") or {}
+        self.expose = expose.get("ports")
+        self.expose_public = expose.get("portsPublic")
+
+        # Inferred fields
+        self.endpoint = kwargs.get("endpoint", constants.ENDPOINT)
+        self.url = f"{self.endpoint}/jobs/{self.owner.name}/{self.id}"
+
+
+@dataclass
+class JobSpec:
+    docker_image: str | None
+    space_id: str | None
+    command: list[str] | None
+    arguments: list[str] | None
+    environment: dict[str, Any] | None
+    secrets: dict[str, Any] | None
+    flavor: JobHardware | None
+    timeout: int | None
+    tags: list[str] | None
+    arch: str | None
+    labels: dict[str, str] | None
+    volumes: list[Volume] | None
+    retry: int | None
+    expose: list[int] | None
+    expose_public: list[int] | None
+
+    def __init__(self, **kwargs) -> None:
+        self.docker_image = kwargs.get("dockerImage") or kwargs.get("docker_image")
+        self.space_id = kwargs.get("spaceId") or kwargs.get("space_id")
+        self.command = kwargs.get("command")
+        self.arguments = kwargs.get("arguments")
+        self.environment = kwargs.get("environment")
+        self.secrets = kwargs.get("secrets")
+        self.flavor = kwargs.get("flavor")
+        self.timeout = kwargs.get("timeout")
+        self.tags = kwargs.get("tags")
+        self.arch = kwargs.get("arch")
+        self.labels = kwargs.get("labels")
+        volumes = kwargs.get("volumes")
+        self.volumes = [Volume(**v) for v in volumes] if volumes else None
+        self.retry = kwargs.get("retry")
+        expose = kwargs.get("expose") or {}
+        self.expose = expose.get("ports")
+        self.expose_public = expose.get("portsPublic")
+
+
+@dataclass
+class LastJobInfo:
+    id: str
+    at: datetime
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        self.at = parse_datetime(kwargs["at"])
+
+
+@dataclass
+class ScheduledJobStatus:
+    last_job: LastJobInfo | None
+    next_job_run_at: datetime | None
+
+    def __init__(self, **kwargs) -> None:
+        last_job = kwargs.get("lastJob") or kwargs.get("last_job")
+        self.last_job = LastJobInfo(**last_job) if last_job else None
+        next_job_run_at = kwargs.get("nextJobRunAt") or kwargs.get("next_job_run_at")
+        self.next_job_run_at = parse_datetime(str(next_job_run_at)) if next_job_run_at else None
+
+
+@dataclass
+class ScheduledJobInfo:
+    """
+    Contains information about a Job.
+
+    Args:
+        id (`str`):
+            Scheduled Job ID.
+        created_at (`datetime` or `None`):
+            When the scheduled Job was created.
+        tags (`list[str]` or `None`):
+            The tags of the scheduled Job.
+        schedule (`str` or `None`):
+            One of "@annually", "@yearly", "@monthly", "@weekly", "@daily", "@hourly", or a
+            CRON schedule expression (e.g., '0 9 * * 1' for 9 AM every Monday).
+        suspend (`bool` or `None`):
+            Whether the scheduled job is suspended (paused).
+        concurrency (`bool` or `None`):
+            Whether multiple instances of this Job can run concurrently.
+        status (`ScheduledJobStatus` or `None`):
+            Status of the scheduled Job.
+        owner: (`JobOwner` or `None`):
+            Owner of the scheduled Job, e.g. `JobOwner(id="5e9ecfc04957053f60648a3e", name="lhoestq", type="user")`
+        job_spec: (`JobSpec` or `None`):
+            Specifications of the Job.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import run_job
+    >>> scheduled_job = create_scheduled_job(
+    ...     image="python:3.12",
+    ...     command=["python", "-c", "print('Hello from the cloud!')"],
+    ...     schedule="@hourly",
+    ... )
+    >>> scheduled_job.id
+    '687fb701029421ae5549d999'
+    >>> scheduled_job.status.next_job_run_at
+    datetime.datetime(2025, 7, 22, 17, 6, 25, 79000, tzinfo=datetime.timezone.utc)
+    ```
+    """
+
+    id: str
+    created_at: datetime | None
+    job_spec: JobSpec
+    schedule: str | None
+    suspend: bool | None
+    concurrency: bool | None
+    status: ScheduledJobStatus
+    owner: JobOwner
+
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs["id"]
+        created_at = kwargs.get("createdAt") or kwargs.get("created_at")
+        self.created_at = parse_datetime(created_at) if created_at else None
+        self.job_spec = JobSpec(**(kwargs.get("job_spec") or kwargs.get("jobSpec", {})))
+        self.schedule = kwargs.get("schedule")
+        self.suspend = kwargs.get("suspend")
+        self.concurrency = kwargs.get("concurrency")
+        status = kwargs.get("status", {})
+        self.status = ScheduledJobStatus(
+            last_job=status.get("last_job") or status.get("lastJob"),
+            next_job_run_at=status.get("next_job_run_at") or status.get("nextJobRunAt"),
+        )
+        owner = kwargs.get("owner", {})
+        self.owner = JobOwner(id=owner["id"], name=owner["name"], type=owner["type"])
+
+
+@dataclass
+class JobAccelerator:
+    """
+    Contains information about a Job accelerator (GPU).
+
+    Args:
+        type (`str`):
+            Type of accelerator, e.g. `"gpu"`.
+        model (`str`):
+            Model of accelerator, e.g. `"T4"`, `"A10G"`, `"A100"`, `"L4"`, `"L40S"`.
+        quantity (`str`):
+            Number of accelerators, e.g. `"1"`, `"2"`, `"4"`, `"8"`.
+        vram (`str`):
+            Total VRAM, e.g. `"16 GB"`, `"24 GB"`.
+        manufacturer (`str`):
+            Manufacturer of the accelerator, e.g. `"Nvidia"`.
+    """
+
+    type: str
+    model: str
+    quantity: str
+    vram: str
+    manufacturer: str
+
+    def __init__(self, **kwargs) -> None:
+        self.type = kwargs["type"]
+        self.model = kwargs["model"]
+        self.quantity = kwargs["quantity"]
+        self.vram = kwargs["vram"]
+        self.manufacturer = kwargs["manufacturer"]
+
+
+@dataclass
+class JobHardwareInfo:
+    """
+    Contains information about available Job hardware.
+
+    Args:
+        name (`str`):
+            Machine identifier, e.g. `"cpu-basic"`, `"a10g-large"`.
+        pretty_name (`str`):
+            Human-readable name, e.g. `"CPU Basic"`, `"Nvidia A10G - large"`.
+        cpu (`str`):
+            CPU specification, e.g. `"2 vCPU"`, `"12 vCPU"`.
+        ram (`str`):
+            RAM specification, e.g. `"16 GB"`, `"46 GB"`.
+        ephemeral_storage (`str`):
+            Ephemeral storage specification, e.g. `"20 GB"`, `"100 GB"`.
+        accelerator (`JobAccelerator` or `None`):
+            GPU/accelerator details if available.
+        unit_cost_micro_usd (`int`):
+            Cost in micro-dollars per unit, e.g. `167` (= $0.000167).
+        unit_cost_usd (`float`):
+            Cost in USD per unit, e.g. `0.000167`.
+        unit_label (`str`):
+            Cost unit period, e.g. `"minute"`.
+
+    Example:
+
+    ```python
+    >>> from huggingface_hub import list_jobs_hardware
+    >>> hardware_list = list_jobs_hardware()
+    >>> hardware_list[0]
+    JobHardwareInfo(name='cpu-basic', pretty_name='CPU Basic', cpu='2 vCPU', ram='16 GB', ephemeral_storage='20 GB', accelerator=None, unit_cost_micro_usd=167, unit_cost_usd=0.000167, unit_label='minute')
+    >>> hardware_list[0].name
+    'cpu-basic'
+    ```
+    """
+
+    name: str
+    pretty_name: str
+    cpu: str
+    ram: str
+    ephemeral_storage: str
+    accelerator: JobAccelerator | None
+    unit_cost_micro_usd: int
+    unit_cost_usd: float
+    unit_label: str
+
+    def __init__(self, **kwargs) -> None:
+        self.name = kwargs["name"]
+        self.pretty_name = kwargs["prettyName"]
+        self.cpu = kwargs["cpu"]
+        self.ram = kwargs["ram"]
+        self.ephemeral_storage = kwargs.get("ephemeralStorage", "N/A")
+        accelerator = kwargs.get("accelerator")
+        self.accelerator = JobAccelerator(**accelerator) if accelerator else None
+        self.unit_cost_micro_usd = kwargs["unitCostMicroUSD"]
+        self.unit_cost_usd = kwargs["unitCostUSD"]
+        self.unit_label = kwargs["unitLabel"]
+
+
+def _derive_job_volume_name(source: str | Path) -> str:
+    """Derive a stable remote folder name for a local directory synced as a Job volume.
+
+    The name is `{dirname}-{hash}` where the hash fingerprints the absolute path and the machine's
+    hostname: re-syncing the same directory from the same machine reuses the same remote folder
+    (so only changed files are re-uploaded), while same-named directories from different paths or
+    machines don't collide.
+    """
+    resolved = Path(source).expanduser().resolve()
+    digest = hashlib.sha256(f"{platform.node()}:{resolved}".encode()).hexdigest()[:8]
+    dirname = resolved.name.replace(" ", "_") or "root"
+    return f"{dirname}-{digest}"
+
+
+def _sanitize_job_name(name: str) -> str:
+    """Sanitize a string so it is a valid Job `name` label.
+
+    Job names must match `^[a-zA-Z0-9._-]*$` and are also stored as tags, which only allow
+    alphanumerics, `-` and `_`. Every other character (including `/`, `:` and `.`) is replaced with `-`.
+    """
+    return re.sub(r"[^a-zA-Z0-9_-]", "-", name)
+
+
+def _short_invocation_hash(parts: list[str]) -> str:
+    """Short, stable hash of a Job invocation (image/script + command line).
+
+    Appended to auto-generated names so reruns of the same command share a name while different ones don't.
+    """
+    return hashlib.sha256("\x00".join(parts).encode()).hexdigest()[:8]
+
+
+def _default_job_name_from_image(image: str, command: list[str], *, config_parts: list[str] | None = None) -> str:
+    """Derive a default Job name from a Docker image or Space reference and its command.
+
+    A short hash of the full command line is appended to group reruns of the same command.
+    e.g. python:3.12 + [foo, --truc]             -> python-3-12-1a2b3c4d
+         hf.co/spaces/lhoestq/duckdb             -> lhoestq-duckdb-<hash>
+         pytorch/pytorch:2.6.0-cuda12.4-...      -> pytorch-2-6-0-cuda12-4-...-<hash>
+
+    `config_parts` adds the rest of the resolved launch configuration (flavor, env, ...) to the hash.
+    The CLI passes it so that the name reflects the values actually submitted.
+    """
+    for prefix in _SPACE_IMAGE_PREFIXES:
+        if image.startswith(prefix):
+            base = _sanitize_job_name(image[len(prefix) :] or image)
+            break
+    else:
+        base = _sanitize_job_name(image.rstrip("/").split("/")[-1] or image)  # drop registry host and namespace
+    return f"{base}-{_short_invocation_hash([image, *command, *(config_parts or [])])}"
+
+
+def _default_job_name_from_script(
+    script: str, script_args: list[str], *, config_parts: list[str] | None = None
+) -> str:
+    """Derive a default Job name from a UV script path, URL, or command and its arguments.
+
+    A short hash of the full command line is appended to group reruns of the same command.
+    e.g. my_script.py + [--epochs, 3]  -> my_script-1a2b3c4d
+         https://.../sft.py?raw=1      -> sft-<hash>
+         lighteval                     -> lighteval-<hash>
+
+    `config_parts` adds the rest of the resolved launch configuration (image, flavor, env, ...) to the
+    hash. The CLI passes it so that the name reflects the values actually submitted, including those
+    coming from a script's `[tool.hf-jobs]` header rather than from the command line.
+    """
+    name = script.split("?", 1)[0].split("#", 1)[0].rstrip("/").split("/")[-1]
+    if name.endswith(".py"):
+        name = name[: -len(".py")]
+    base = _sanitize_job_name(name or script)
+    return f"{base}-{_short_invocation_hash([script, *script_args, *(config_parts or [])])}"
+
+
+def _build_expose_payload(expose: list[int] | None, expose_public: list[int] | None) -> dict[str, list[int]]:
+    # Public ports are exposed too: the server expects them in both lists (`portsPublic` must be a subset of `ports`).
+    ports_public = list(dict.fromkeys(expose_public or []))
+    return {"ports": list(dict.fromkeys([*(expose or []), *ports_public])), "portsPublic": ports_public}
+
+
+def _create_job_spec(
+    *,
+    image: str,
+    command: list[str],
+    env: dict[str, Any] | None,
+    secrets: dict[str, Any] | None,
+    flavor: JobHardware | str | None,
+    timeout: int | float | str | None,
+    name: str | None = None,
+    labels: dict[str, str] | None = None,
+    volumes: list[Volume] | None = None,
+    expose: list[int] | None = None,
+    expose_public: list[int] | None = None,
+    ssh: bool = False,
+    network_group: str | None = None,
+    network_aliases: list[str] | None = None,
+    resource_group_id: str | None = None,
+    attempts: int | None = None,
+) -> dict[str, Any]:
+    if network_aliases and not network_group:
+        raise ValueError("`network_aliases` requires `network_group`.")
+    if name is not None:
+        if labels is not None and "name" in labels:
+            raise ValueError("`name` and the `name` key in `labels` cannot both be provided.")
+        labels = {**(labels or {}), "name": name}
+
+    # prepare job spec to send to HF Jobs API
+    job_spec: dict[str, Any] = {
+        "command": command,
+        "arguments": [],
+        "environment": env or {},
+        "flavor": flavor or JobHardware.CPU_BASIC,
+    }
+    # secrets are optional
+    if secrets:
+        job_spec["secrets"] = secrets
+    # timeout is optional
+    if timeout:
+        time_units_factors = {"s": 1, "m": 60, "h": 3600, "d": 3600 * 24}
+        if isinstance(timeout, str) and timeout[-1] in time_units_factors:
+            job_spec["timeoutSeconds"] = int(float(timeout[:-1]) * time_units_factors[timeout[-1]])
+        else:
+            job_spec["timeoutSeconds"] = int(timeout)
+    if attempts is not None:
+        job_spec["attempts"] = attempts
+    # labels are optional
+    if labels:
+        job_spec["labels"] = labels
+    # volumes are optional
+    if volumes:
+        job_spec["volumes"] = [vol.to_dict() for vol in volumes]
+    # expose ports through the jobs proxy
+    if expose or expose_public:
+        job_spec["expose"] = _build_expose_payload(expose, expose_public)
+    # make the job container reachable over SSH
+    if ssh:
+        job_spec["ssh"] = {"enabled": True}
+    # join a network group, optionally claiming aliases in it
+    if network_group:
+        network: dict[str, Any] = {"group": network_group}
+        if network_aliases:
+            network["aliases"] = network_aliases
+        job_spec["network"] = network
+    # resource group is optional
+    if resource_group_id:
+        job_spec["resourceGroupId"] = resource_group_id
+    # input is either from docker hub or from HF spaces
+    for prefix in _SPACE_IMAGE_PREFIXES:
+        if image.startswith(prefix):
+            job_spec["spaceId"] = image[len(prefix) :]
+            break
+    else:
+        job_spec["dockerImage"] = image
+    return job_spec
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_local_folder.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_local_folder.py
new file mode 100644
index 0000000000000000000000000000000000000000..4863292c5741431714d06d1ae53b116c3de0aa46
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_local_folder.py
@@ -0,0 +1,492 @@
+# Copyright 2024-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains utilities to handle the `../.cache/huggingface` folder in local directories.
+
+First discussed in https://github.com/huggingface/huggingface_hub/issues/1738 to store
+download metadata when downloading files from the hub to a local directory (without
+using the cache).
+
+./.cache/huggingface folder structure:
+[4.0K]  data
+├── [4.0K]  .cache
+│   └── [4.0K]  huggingface
+│       └── [4.0K]  download
+│           ├── [  16]  file.parquet.metadata
+│           ├── [  16]  file.txt.metadata
+│           └── [4.0K]  folder
+│               └── [  16]  file.parquet.metadata
+│
+├── [6.5G]  file.parquet
+├── [1.5K]  file.txt
+└── [4.0K]  folder
+    └── [   16]  file.parquet
+
+
+Download metadata file structure:
+```
+# file.txt.metadata
+11c5a3d5811f50298f278a704980280950aedb10
+a16a55fda99d2f2e7b69cce5cf93ff4ad3049930
+1712656091.123
+
+# file.parquet.metadata
+11c5a3d5811f50298f278a704980280950aedb10
+7c5d3f4b8b76583b422fcb9189ad6c89d5d97a094541ce8932dce3ecabde1421
+1712656091.123
+}
+```
+"""
+
+import base64
+import hashlib
+import logging
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path, PurePosixPath, PureWindowsPath
+
+from .utils import WeakFileLock
+from .utils._paths import as_extended_path
+
+
+logger = logging.getLogger(__name__)
+
+CACHEDIR_TAG_CONTENT = (
+    "Signature: 8a477f597d28d172789f06886806bc55\n"
+    "# This file is a cache directory tag created by huggingface_hub.\n"
+    "# For information about cache directory tags, see:\n"
+    "#\thttps://bford.info/cachedir/\n"
+)
+
+
+@dataclass
+class LocalDownloadFilePaths:
+    """
+    Paths to the files related to a download process in a local dir.
+
+    Returned by [`get_local_download_paths`].
+
+    Attributes:
+        file_path (`Path`):
+            Path where the file will be saved.
+        lock_path (`Path`):
+            Path to the lock file used to ensure atomicity when reading/writing metadata.
+        metadata_path (`Path`):
+            Path to the metadata file.
+    """
+
+    file_path: Path
+    lock_path: Path
+    metadata_path: Path
+
+    def incomplete_path(self, etag: str) -> Path:
+        """Return the path where a file will be temporarily downloaded before being moved to `file_path`."""
+        path = self.metadata_path.parent / f"{_short_hash(self.metadata_path.name)}.{etag}.incomplete"
+        return Path(as_extended_path(path))
+
+
+@dataclass(frozen=True)
+class LocalUploadFilePaths:
+    """
+    Paths to the files related to an upload process in a local dir.
+
+    Returned by [`get_local_upload_paths`].
+
+    Attributes:
+        path_in_repo (`str`):
+            Path of the file in the repo.
+        file_path (`Path`):
+            Path where the file will be saved.
+        lock_path (`Path`):
+            Path to the lock file used to ensure atomicity when reading/writing metadata.
+        metadata_path (`Path`):
+            Path to the metadata file.
+    """
+
+    path_in_repo: str
+    file_path: Path
+    lock_path: Path
+    metadata_path: Path
+
+
+@dataclass
+class LocalDownloadFileMetadata:
+    """
+    Metadata about a file in the local directory related to a download process.
+
+    Attributes:
+        filename (`str`):
+            Path of the file in the repo.
+        commit_hash (`str`):
+            Commit hash of the file in the repo.
+        etag (`str`):
+            ETag of the file in the repo. Used to check if the file has changed.
+            For LFS files, this is the sha256 of the file. For regular files, it corresponds to the git hash.
+        timestamp (`int`):
+            Unix timestamp of when the metadata was saved i.e. when the metadata was accurate.
+    """
+
+    filename: str
+    commit_hash: str
+    etag: str
+    timestamp: float
+
+
+@dataclass
+class LocalUploadFileMetadata:
+    """
+    Metadata about a file in the local directory related to an upload process.
+    """
+
+    size: int
+
+    # Default values correspond to "we don't know yet"
+    timestamp: float | None = None
+    should_ignore: bool | None = None
+    sha256: str | None = None
+    upload_mode: str | None = None
+    remote_oid: str | None = None
+    is_uploaded: bool = False
+    is_committed: bool = False
+
+    def save(self, paths: LocalUploadFilePaths) -> None:
+        """Save the metadata to disk."""
+        with WeakFileLock(paths.lock_path):
+            with paths.metadata_path.open("w") as f:
+                new_timestamp = time.time()
+                f.write(str(new_timestamp) + "\n")
+
+                f.write(str(self.size))  # never None
+                f.write("\n")
+
+                if self.should_ignore is not None:
+                    f.write(str(int(self.should_ignore)))
+                f.write("\n")
+
+                if self.sha256 is not None:
+                    f.write(self.sha256)
+                f.write("\n")
+
+                if self.upload_mode is not None:
+                    f.write(self.upload_mode)
+                f.write("\n")
+
+                if self.remote_oid is not None:
+                    f.write(self.remote_oid)
+                f.write("\n")
+
+                f.write(str(int(self.is_uploaded)) + "\n")
+                f.write(str(int(self.is_committed)) + "\n")
+
+            self.timestamp = new_timestamp
+
+
+def _validate_relative_filename(filename: str) -> None:
+    """Validate that a repo filename is safe to use as a path relative to a local directory.
+
+    A repo filename is a POSIX-style ('/'-separated) path relative to the repo root. When materialized
+    on disk (in `local_dir` or in the cache), it is joined onto a base directory. A malicious repository
+    could craft a filename that escapes that base directory, resulting in an arbitrary file write:
+
+    - an absolute path (`/etc/...`),
+    - a Windows drive path (`C:\\Windows\\...`) or drive-relative path (`D:foo`),
+    - a UNC path (`\\\\attacker-host\\share\\...`) — which on Windows additionally makes the client
+      authenticate to the attacker's SMB server during path resolution, leaking a NetNTLMv2 hash,
+    - a path using `..` to traverse upward.
+
+    Such filenames would otherwise cause `local_dir / filename` to discard `local_dir` (when the right
+    side is anchored) or point outside of it (with `..`). We reject them here, before touching the
+    filesystem. The check runs on all platforms and interprets the name under both POSIX and Windows
+    rules, so a file materialized on Linux cannot escape when later consumed on Windows.
+    """
+    # Reject parent-directory traversal ('..' as any segment, whether '/'- or '\'-separated).
+    if ".." in filename.replace("\\", "/").split("/"):
+        raise ValueError(
+            f"Invalid filename '{filename}': cannot contain a '..' path segment. "
+            "Please ask the repository owner to rename this file."
+        )
+    # Reject anchored paths (absolute / drive / root-relative / UNC) under either OS's rules.
+    # Check each POSIX segment under Windows rules because os.path.join handles them separately.
+    pure_paths = [PurePosixPath(filename), *(PureWindowsPath(part) for part in filename.split("/"))]
+    for pure_path in pure_paths:
+        if pure_path.drive or pure_path.root:
+            raise ValueError(
+                f"Invalid filename '{filename}': cannot be an absolute, drive-relative or UNC path. "
+                "Please ask the repository owner to rename this file."
+            )
+
+
+def get_local_download_paths(local_dir: Path, filename: str) -> LocalDownloadFilePaths:
+    """Compute paths to the files related to a download process.
+
+    Folders containing the paths are all guaranteed to exist.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        [`LocalDownloadFilePaths`]: the paths to the files (file_path, lock_path, metadata_path, incomplete_path).
+    """
+    _validate_relative_filename(filename)
+    # filename is the path in the Hub repository (separated by '/')
+    # make sure to have a cross-platform transcription
+    sanitized_filename = os.path.join(*filename.split("/"))
+    file_path = local_dir / sanitized_filename
+    metadata_path = _huggingface_dir(local_dir) / "download" / f"{sanitized_filename}.metadata"
+    lock_path = metadata_path.with_suffix(".lock")
+
+    # Parent directories are created below => use the stricter Windows limit for directories.
+    file_path = Path(as_extended_path(file_path, max_length=247))
+    lock_path = Path(as_extended_path(lock_path, max_length=247))
+    metadata_path = Path(as_extended_path(metadata_path, max_length=247))
+
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    return LocalDownloadFilePaths(file_path=file_path, lock_path=lock_path, metadata_path=metadata_path)
+
+
+def get_local_upload_paths(local_dir: Path, filename: str) -> LocalUploadFilePaths:
+    """Compute paths to the files related to an upload process.
+
+    Folders containing the paths are all guaranteed to exist.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory that is uploaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        [`LocalUploadFilePaths`]: the paths to the files (file_path, lock_path, metadata_path).
+    """
+    _validate_relative_filename(filename)
+    # filename is the path in the Hub repository (separated by '/')
+    # make sure to have a cross-platform transcription
+    sanitized_filename = os.path.join(*filename.split("/"))
+    file_path = local_dir / sanitized_filename
+    metadata_path = _huggingface_dir(local_dir) / "upload" / f"{sanitized_filename}.metadata"
+    lock_path = metadata_path.with_suffix(".lock")
+
+    # Parent directories are created below => use the stricter Windows limit for directories.
+    file_path = Path(as_extended_path(file_path, max_length=247))
+    lock_path = Path(as_extended_path(lock_path, max_length=247))
+    metadata_path = Path(as_extended_path(metadata_path, max_length=247))
+
+    file_path.parent.mkdir(parents=True, exist_ok=True)
+    metadata_path.parent.mkdir(parents=True, exist_ok=True)
+    return LocalUploadFilePaths(
+        path_in_repo=filename, file_path=file_path, lock_path=lock_path, metadata_path=metadata_path
+    )
+
+
+def read_download_metadata(local_dir: Path, filename: str) -> LocalDownloadFileMetadata | None:
+    """Read metadata about a file in the local directory related to a download process.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        `[LocalDownloadFileMetadata]` or `None`: the metadata if it exists, `None` otherwise.
+    """
+    paths = get_local_download_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        if paths.metadata_path.exists():
+            try:
+                with paths.metadata_path.open() as f:
+                    commit_hash = f.readline().strip()
+                    etag = f.readline().strip()
+                    timestamp = float(f.readline().strip())
+                    metadata = LocalDownloadFileMetadata(
+                        filename=filename,
+                        commit_hash=commit_hash,
+                        etag=etag,
+                        timestamp=timestamp,
+                    )
+            except Exception as e:
+                # remove the metadata file if it is corrupted / not the right format
+                logger.warning(
+                    f"Invalid metadata file {paths.metadata_path}: {e}. Removing it from disk and continue."
+                )
+                try:
+                    paths.metadata_path.unlink()
+                except Exception as e:
+                    logger.warning(f"Could not remove corrupted metadata file {paths.metadata_path}: {e}")
+                return None
+
+            try:
+                # check if the file exists and hasn't been modified since the metadata was saved
+                stat = paths.file_path.stat()
+                if (
+                    stat.st_mtime - 1 <= metadata.timestamp
+                ):  # allow 1s difference as stat.st_mtime might not be precise
+                    return metadata
+                logger.info(f"Ignored metadata for '{filename}' (outdated). Will re-compute hash.")
+            except FileNotFoundError:
+                # file does not exist => metadata is outdated
+                return None
+    return None
+
+
+def read_upload_metadata(local_dir: Path, filename: str) -> LocalUploadFileMetadata:
+    """Read metadata about a file in the local directory related to an upload process.
+
+    TODO: factorize logic with `read_download_metadata`.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+        filename (`str`):
+            Path of the file in the repo.
+
+    Return:
+        `[LocalUploadFileMetadata]` or `None`: the metadata if it exists, `None` otherwise.
+    """
+    paths = get_local_upload_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        if paths.metadata_path.exists():
+            try:
+                with paths.metadata_path.open() as f:
+                    timestamp = float(f.readline().strip())
+
+                    size = int(f.readline().strip())  # never None
+
+                    _should_ignore = f.readline().strip()
+                    should_ignore = None if _should_ignore == "" else bool(int(_should_ignore))
+
+                    _sha256 = f.readline().strip()
+                    sha256 = None if _sha256 == "" else _sha256
+
+                    _upload_mode = f.readline().strip()
+                    upload_mode = None if _upload_mode == "" else _upload_mode
+                    if upload_mode not in (None, "regular", "lfs"):
+                        raise ValueError(f"Invalid upload mode in metadata {paths.path_in_repo}: {upload_mode}")
+
+                    _remote_oid = f.readline().strip()
+                    remote_oid = None if _remote_oid == "" else _remote_oid
+
+                    is_uploaded = bool(int(f.readline().strip()))
+                    is_committed = bool(int(f.readline().strip()))
+
+                    metadata = LocalUploadFileMetadata(
+                        timestamp=timestamp,
+                        size=size,
+                        should_ignore=should_ignore,
+                        sha256=sha256,
+                        upload_mode=upload_mode,
+                        remote_oid=remote_oid,
+                        is_uploaded=is_uploaded,
+                        is_committed=is_committed,
+                    )
+            except Exception as e:
+                # remove the metadata file if it is corrupted / not the right format
+                logger.warning(
+                    f"Invalid metadata file {paths.metadata_path}: {e}. Removing it from disk and continue."
+                )
+                try:
+                    paths.metadata_path.unlink()
+                except Exception as e:
+                    logger.warning(f"Could not remove corrupted metadata file {paths.metadata_path}: {e}")
+
+                # corrupted metadata => we don't know anything expect its size
+                return LocalUploadFileMetadata(size=paths.file_path.stat().st_size)
+
+            # TODO: can we do better?
+            if (
+                metadata.timestamp is not None
+                and metadata.is_uploaded  # file was uploaded
+                and not metadata.is_committed  # but not committed
+                and time.time() - metadata.timestamp > 20 * 3600  # and it's been more than 20 hours
+            ):  # => we consider it as garbage-collected by S3
+                metadata.is_uploaded = False
+
+            # check if the file exists and hasn't been modified since the metadata was saved
+            try:
+                if metadata.timestamp is not None and paths.file_path.stat().st_mtime <= metadata.timestamp:
+                    return metadata
+                logger.info(f"Ignored metadata for '{filename}' (outdated). Will re-compute hash.")
+            except FileNotFoundError:
+                # file does not exist => metadata is outdated
+                pass
+
+    # empty metadata => we don't know anything expect its size
+    return LocalUploadFileMetadata(size=paths.file_path.stat().st_size)
+
+
+def write_download_metadata(local_dir: Path, filename: str, commit_hash: str, etag: str) -> None:
+    """Write metadata about a file in the local directory related to a download process.
+
+    Args:
+        local_dir (`Path`):
+            Path to the local directory in which files are downloaded.
+    """
+    paths = get_local_download_paths(local_dir, filename)
+    with WeakFileLock(paths.lock_path):
+        with paths.metadata_path.open("w") as f:
+            f.write(f"{commit_hash}\n{etag}\n{time.time()}\n")
+
+
+def _huggingface_dir(local_dir: Path) -> Path:
+    """Return the path to the `.cache/huggingface` directory in a local directory."""
+    # Wrap in lru_cache to avoid overwriting the .gitignore file if called multiple times
+    path = local_dir / ".cache" / "huggingface"
+    # Creating the `.cache/huggingface` directory (and the bookkeeping files below) fails for a deep `local_dir`, so
+    # the filesystem operations go through the extended-length form. The un-prefixed `path` is still returned so
+    # callers keep re-deriving/prefixing as before.
+    target = Path(as_extended_path(path, max_length=247))
+    target.mkdir(exist_ok=True, parents=True)
+
+    # Create a CACHEDIR.TAG so backup tools can skip this directory.
+    _create_cachedir_tag(target)
+
+    # Create a .gitignore file in the .cache/huggingface directory if it doesn't exist
+    # Should be thread-safe enough like this.
+    gitignore = target / ".gitignore"
+    gitignore_lock = target / ".gitignore.lock"
+    if not gitignore.exists():
+        try:
+            with WeakFileLock(gitignore_lock, timeout=0.1):
+                gitignore.write_text("*")
+        except IndexError:
+            pass
+        except OSError:  # TimeoutError, FileNotFoundError, PermissionError, etc.
+            pass
+        try:
+            gitignore_lock.unlink()
+        except OSError:
+            pass
+    return path
+
+
+def _create_cachedir_tag(cache_dir: Path) -> None:
+    """Create a CACHEDIR.TAG file in ``cache_dir`` if one does not already exist.
+
+    The tag follows the `Cache Directory Tagging Standard <http://www.brynosaurus.com/cachedir/>`_
+    so that backup tools can recognize and skip cache directories.
+    """
+    tag_path = cache_dir / "CACHEDIR.TAG"
+    if not tag_path.exists():
+        try:
+            tag_path.write_text(CACHEDIR_TAG_CONTENT)
+        except OSError:
+            pass
+
+
+def _short_hash(filename: str) -> str:
+    return base64.urlsafe_b64encode(hashlib.sha1(filename.encode()).digest()).decode()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_login.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_login.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8fcdc55b778f9423701664aa29ca65f08c4a229
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_login.py
@@ -0,0 +1,559 @@
+# Copyright 2020 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.
+"""Contains methods to log in to the Hub."""
+
+import html
+import os
+import subprocess
+import sys
+import time
+from datetime import datetime
+from getpass import getpass
+from pathlib import Path
+
+from . import constants
+from .errors import DeviceCodeError
+from .utils import (
+    ANSI,
+    get_token,
+    is_google_colab,
+    is_notebook,
+    list_credential_helpers,
+    logging,
+    run_subprocess,
+    select_choice,
+    set_git_credential,
+    tabulate,
+    unset_git_credential,
+)
+from .utils._auth import (
+    _get_token_by_name,
+    _get_token_from_environment,
+    _get_token_from_file,
+    _get_token_from_google_colab,
+    _read_stored_tokens_full,
+    _save_stored_tokens_full,
+    _save_token,
+    _write_secret,
+    get_stored_tokens,
+)
+from .utils._oauth_device import OAuthTokenResponse, poll_device_token, request_device_code
+
+
+logger = logging.get_logger(__name__)
+
+
+def login(
+    token: str | None = None,
+    *,
+    add_to_git_credential: bool = False,
+    skip_if_logged_in: bool = True,
+) -> None:
+    """Login the machine to access the Hub.
+
+    The `token` is persisted in cache and set as a git credential. Once done, the machine
+    is logged in and the access token will be available across all `huggingface_hub`
+    components. If `token` is not provided, a browser-based OAuth flow is used to
+    authenticate: open a URL, enter a short code, and the token is retrieved and saved.
+    In a terminal, you can also choose to paste an existing access token instead.
+
+    To log in from outside of a script, one can also use `hf auth login` which is
+    a cli command that wraps [`login`].
+
+    > [!TIP]
+    > When the token is not passed, [`login`] will automatically detect if the script runs
+    > in a notebook or not. However, this detection might not be accurate due to the
+    > variety of notebooks that exists nowadays. If that is the case, you can always force
+    > the UI by using [`notebook_login`] or [`interpreter_login`].
+
+    Args:
+        token (`str`, *optional*):
+            User access token to generate from https://huggingface.co/settings/token.
+        add_to_git_credential (`bool`, defaults to `False`):
+            If `True`, token will be set as git credential. If no git credential helper
+            is configured, a warning will be displayed to the user. Only used when `token`
+            is provided; ignored by the browser-based flow.
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If an organization token is passed. Only personal account tokens are valid
+            to log in.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If token is invalid.
+        [`DeviceCodeError`]
+            If the browser-based login fails (authorization denied, code expired, ...).
+    """
+    if token is not None:
+        if not add_to_git_credential:
+            logger.info(
+                "The token has not been saved to the git credentials helper. Pass "
+                "`add_to_git_credential=True` in this function directly or "
+                "`--add-to-git-credential` if using via `hf`CLI if "
+                "you want to set the git credential as well."
+            )
+        _validate_and_save_token(token, add_to_git_credential=add_to_git_credential)
+        return
+    if add_to_git_credential:
+        logger.warning(
+            "`add_to_git_credential=True` is only supported when a token is passed directly. "
+            "It is ignored by the browser-based login."
+        )
+    if is_notebook():
+        notebook_login(skip_if_logged_in=skip_if_logged_in)
+    else:
+        interpreter_login(skip_if_logged_in=skip_if_logged_in)
+
+
+def logout(token_name: str | None = None) -> None:
+    """Logout the machine from the Hub.
+
+    Token is deleted from the machine and removed from git credential.
+
+    Args:
+        token_name (`str`, *optional*):
+            Name of the access token to logout from. If `None`, will log out from all saved access tokens.
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError):
+            If the access token name is not found.
+    """
+    if get_token() is None and not get_stored_tokens():  # No active token and no saved access tokens
+        logger.warning("Not logged in!")
+        return
+    if not token_name:
+        # Delete all saved access tokens and token
+        for file_path in (constants.HF_TOKEN_PATH, constants.HF_STORED_TOKENS_PATH):
+            try:
+                Path(file_path).unlink()
+            except FileNotFoundError:
+                pass
+        logger.info("Successfully logged out from all access tokens.")
+    else:
+        _logout_from_token(token_name)
+        logger.info(f"Successfully logged out from access token: {token_name}.")
+
+    unset_git_credential()
+
+    # Check if still logged in
+    if _get_token_from_google_colab() is not None:
+        raise OSError(
+            "You are automatically logged in using a Google Colab secret.\n"
+            "To log out, you must unset the `HF_TOKEN` secret in your Colab settings."
+        )
+    if _get_token_from_environment() is not None:
+        raise OSError(
+            "Token has been deleted from your machine but you are still logged in.\n"
+            "To log out, you must clear out both `HF_TOKEN` and `HUGGING_FACE_HUB_TOKEN` environment variables."
+        )
+
+
+def auth_switch(token_name: str, add_to_git_credential: bool = False) -> None:
+    """Switch to a different access token.
+
+    Args:
+        token_name (`str`):
+            Name of the access token to switch to.
+        add_to_git_credential (`bool`, defaults to `False`):
+            If `True`, token will be set as git credential. If no git credential helper
+            is configured, a warning will be displayed to the user. If `token` is `None`,
+            the value of `add_to_git_credential` is ignored and will be prompted again
+            to the end user.
+
+    Raises:
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError):
+            If the access token name is not found.
+    """
+    token = _get_token_by_name(token_name)
+    if not token:
+        raise ValueError(f"Access token {token_name} not found in {constants.HF_STORED_TOKENS_PATH}")
+    # Write token to HF_TOKEN_PATH
+    _set_active_token(token_name, add_to_git_credential)
+    logger.info(f"The current active token is: {token_name}")
+    token_from_environment = _get_token_from_environment()
+    if token_from_environment is not None and token_from_environment != token:
+        logger.warning(
+            "The environment variable `HF_TOKEN` is set and will override the access token you've just switched to."
+        )
+
+
+def auth_list() -> None:
+    """List all stored access tokens."""
+    # Resolve the current token before reading the file: `get_token()` may refresh an OAuth
+    # token and rewrite the stored tokens on the way.
+    current_token = get_token()
+    stored_tokens = _read_stored_tokens_full()
+
+    if not stored_tokens:
+        if _get_token_from_environment():
+            logger.info("No stored access tokens found.")
+            logger.warning("Note: Environment variable `HF_TOKEN` is set and is the current active token.")
+        else:
+            logger.info("No access tokens found.")
+        return
+    show_expires = any("expires_at" in fields for fields in stored_tokens.values())
+    headers = [" ", "name", "token"] + (["expires"] if show_expires else [])
+
+    current_token_name = None
+    rows: list[list[str | int]] = []
+    for token_name, fields in stored_tokens.items():
+        token = fields.get("hf_token", "<not set>")
+        if token == current_token:
+            current_token_name = token_name
+        masked_token = f"{token[:3]}****{token[-4:]}" if token != "<not set>" else token
+        row: list[str | int] = ["*" if token == current_token else "", token_name, masked_token]
+        if show_expires:
+            row.append(_format_expiration(fields.get("expires_at")))
+        rows.append(row)
+    print(tabulate(rows, headers=headers))
+
+    if _get_token_from_environment():
+        logger.warning(
+            "\nNote: Environment variable `HF_TOKEN` is set and is the current active token independently from the stored tokens listed above."
+        )
+    elif current_token_name is None:
+        logger.warning(
+            "\nNote: No active token is set and no environment variable `HF_TOKEN` is found. Use `hf auth login` to log in."
+        )
+
+
+###
+# Device Code OAuth login (RFC 8628)
+###
+
+
+def _device_code_login() -> None:
+    """Run the Device Code OAuth flow: request a code, prompt the user to authorize it in a browser,
+    poll for the token and save it."""
+    device_info = request_device_code()
+
+    # The complete URI has the code pre-filled when the server supports it.
+    print(f"\n    Open this URL in your browser:\n        {device_info['verification_uri_complete']}\n")
+    print(f"    And enter the code: {device_info['user_code']}\n")
+
+    print("    Waiting for authorization", end="", flush=True)
+    try:
+        response = poll_device_token(device_info, on_pending=lambda: print(".", end="", flush=True))
+    finally:
+        print()  # newline after the progress dots, also on failure
+
+    _save_oauth_token(response)
+
+
+def _save_oauth_token(response: OAuthTokenResponse) -> tuple[str, str]:
+    """Validate and persist a token response from the device code flow, including refresh metadata."""
+    expires_in = response.get("expires_in")
+    token_name, username = _validate_and_save_token(
+        response["access_token"],
+        add_to_git_credential=False,
+        refresh_token=response.get("refresh_token"),
+        expires_at=int(time.time()) + int(expires_in) if expires_in else None,
+    )
+    if note := _expiration_note(response):
+        logger.info(f"Note: {note}")
+    return token_name, username
+
+
+def _expiration_note(response: OAuthTokenResponse) -> str | None:
+    """Human-readable note about the lifetime of a freshly obtained OAuth token, if known."""
+    expires_in = response.get("expires_in")
+    if not expires_in:
+        return None
+    if response.get("refresh_token"):
+        return "This token will be refreshed automatically when it expires."
+    days = max(1, int(expires_in) // 86400)
+    return f"This token expires in {days} days. Log in again to renew it."
+
+
+###
+# Interpreter-based login (text)
+###
+
+
+def interpreter_login(*, skip_if_logged_in: bool = True) -> None:
+    """
+    Displays a prompt to log in to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when not run in a notebook.
+    [`interpreter_login`] is useful if you want to force the use of the terminal prompt
+    instead of a notebook flow.
+
+    For more details, see [`login`].
+
+    Args:
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    """
+    if skip_if_logged_in and get_token() is not None:
+        logger.info("User is already logged in. Use `hf auth login --force` to force re-login.")
+        return
+
+    if get_token() is not None:
+        logger.info("Note: a token is already saved on this machine. Logging in again will replace the active token.")
+
+    if _prompt_login_method() == "token":
+        _paste_token_login()
+    else:
+        _device_code_login()
+
+
+def _prompt_login_method() -> str:
+    """Ask the user how to log in: "browser" (default) or "token". Never prompts without a TTY."""
+    if sys.stdin is None or not sys.stdin.isatty():
+        return "browser"
+    choice = select_choice("How would you like to log in?", ["Log in with your browser", "Paste an access token"])
+    return "browser" if choice == 0 else "token"
+
+
+def _paste_token_login() -> None:
+    logger.info(
+        "    To log in, `huggingface_hub` requires a token generated from https://huggingface.co/settings/tokens ."
+    )
+    if os.name == "nt":
+        logger.info("Token can be pasted using 'Right-Click'.")
+    token = getpass("Enter your token (input will not be visible): ")
+    _validate_and_save_token(token=token, add_to_git_credential=False)
+
+
+###
+# Notebook-based login
+###
+
+
+def notebook_login(*, skip_if_logged_in: bool = True) -> None:
+    """
+    Displays a prompt to log in to the HF website and store the token.
+
+    This is equivalent to [`login`] without passing a token when run in a notebook.
+    [`notebook_login`] is useful if you want to force the use of the notebook flow
+    instead of a prompt in the terminal.
+
+    For more details, see [`login`].
+
+    Args:
+        skip_if_logged_in (`bool`, defaults to `True`):
+            If `True`, do not prompt for token if user is already logged in.
+            Set to `False` to force re-login. In CLI, use `--force` instead.
+    """
+    if skip_if_logged_in and get_token() is not None:
+        logger.info("User is already logged in. Use `hf auth login --force` to force re-login.")
+        return
+
+    try:
+        from IPython.display import HTML, display  # type: ignore
+    except ImportError:
+        # Not in a notebook environment: fall back to the terminal flow
+        interpreter_login(skip_if_logged_in=False)
+        return
+
+    device_info = request_device_code()
+    # Escape server-provided values: they end up in raw notebook HTML.
+    verification_uri = html.escape(device_info["verification_uri"])
+    verification_uri_complete = html.escape(device_info["verification_uri_complete"])
+
+    display(
+        HTML(
+            '<center><img src="https://huggingface.co/front/assets/huggingface_logo-noborder.svg"'
+            ' width="100" alt="Hugging Face"><br><br>'
+            "<p>To log in, open this URL and enter the code:</p>"
+            f'<p><a href="{verification_uri_complete}" target="_blank"><b>{verification_uri}</b></a></p>'
+            '<p style="font-size: 1.6em; letter-spacing: 0.3em; font-family: monospace;">'
+            f"<b>{html.escape(device_info['user_code'])}</b></p></center>"
+        )
+    )
+    display(HTML("<center><i>Waiting for authorization...</i></center>"))
+    try:
+        response = poll_device_token(device_info)
+    except DeviceCodeError as e:
+        display(HTML(f"<center><b style='color: red;'>Login failed: {html.escape(str(e))}</b></center>"))
+        return
+
+    try:
+        token_name, username = _save_oauth_token(response)
+    except Exception as error:
+        display(HTML(f"<center><b style='color: red;'>{html.escape(str(error))}</b></center>"))
+        return
+
+    message = f"Login successful. Logged in as <b>{html.escape(username)}</b> (token: <code>{html.escape(token_name)}</code>)."
+    if note := _expiration_note(response):
+        message += f"<br>{html.escape(note)}"
+    display(HTML(f"<center>{message}</center>"))
+
+
+###
+# Login private helpers
+###
+
+
+def _validate_and_save_token(
+    token: str,
+    add_to_git_credential: bool,
+    refresh_token: str | None = None,
+    expires_at: int | None = None,
+) -> tuple[str, str]:
+    """Validate a token against the Hub, save it to the stored tokens file and set it as active.
+
+    The token is stored under its `displayName` from the whoami response, or `oauth-{username}`
+    for OAuth tokens (which have no display name).
+
+    Args:
+        token (`str`):
+            The access token.
+        add_to_git_credential (`bool`):
+            Whether to save the token to the git credential helpers.
+        refresh_token (`str`, *optional*):
+            OAuth refresh token to persist alongside the access token.
+        expires_at (`int`, *optional*):
+            Unix timestamp at which the access token expires.
+
+    Returns:
+        `tuple[str, str]`: The token name and the username.
+    """
+    from .hf_api import whoami  # avoid circular import
+
+    if token.startswith("api_org"):
+        raise ValueError("You must use your personal account token, not an organization token.")
+
+    token_info = whoami(token)
+    username = token_info["name"]
+
+    access_token_info = (token_info.get("auth") or {}).get("accessToken") or {}
+    if role := access_token_info.get("role"):
+        logger.info(f"Token is valid (permission: {role}).")
+    else:
+        logger.info("Token is valid.")
+
+    token_name = access_token_info.get("displayName") or f"oauth-{username}"
+
+    # Store token locally
+    _save_token(token=token, token_name=token_name, refresh_token=refresh_token, expires_at=expires_at)
+    # Set active token
+    _set_active_token(token_name=token_name, add_to_git_credential=add_to_git_credential)
+    logger.info("Login successful.")
+    if _get_token_from_environment():
+        logger.warning(
+            "Note: Environment variable`HF_TOKEN` is set and is the current active token independently from the token you've just configured."
+        )
+    else:
+        logger.info(f"The current active token is: `{token_name}`")
+    return token_name, username
+
+
+def _logout_from_token(token_name: str) -> None:
+    """Logout from a specific access token.
+
+    Args:
+        token_name (`str`):
+            The name of the access token to logout from.
+    """
+    stored_tokens = _read_stored_tokens_full()
+    # If there is no access tokens saved or the access token name is not found, do nothing
+    if token_name not in stored_tokens:
+        return
+
+    fields = stored_tokens.pop(token_name)
+    _save_stored_tokens_full(stored_tokens)
+
+    if fields.get("hf_token") == _get_token_from_file():
+        logger.warning(f"Active token '{token_name}' has been deleted.")
+        Path(constants.HF_TOKEN_PATH).unlink(missing_ok=True)
+
+
+def _format_expiration(expires_at: str | None) -> str:
+    """Format an `expires_at` unix timestamp for display in `auth list`."""
+    if not expires_at:
+        return ""
+    try:
+        timestamp = int(expires_at)
+    except ValueError:
+        return ""
+    date_str = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d")
+    return f"{date_str} (expired)" if timestamp < time.time() else date_str
+
+
+def _set_active_token(
+    token_name: str,
+    add_to_git_credential: bool,
+) -> None:
+    """Set the active access token.
+
+    Args:
+        token_name (`str`):
+            The name of the token to set as active.
+    """
+    token = _get_token_by_name(token_name)
+    if not token:
+        raise ValueError(f"Token {token_name} not found in {constants.HF_STORED_TOKENS_PATH}")
+    if add_to_git_credential:
+        if _is_git_credential_helper_configured():
+            set_git_credential(token)
+            logger.info(
+                "Your token has been saved in your configured git credential helpers"
+                + f" ({','.join(list_credential_helpers())})."
+            )
+        else:
+            logger.warning("Token has not been saved to git credential helper.")
+    # Write token to HF_TOKEN_PATH
+    _write_secret(Path(constants.HF_TOKEN_PATH), token)
+    logger.info(f"Your token has been saved to {constants.HF_TOKEN_PATH}")
+
+
+def _is_git_credential_helper_configured() -> bool:
+    """Check if a git credential helper is configured.
+
+    Warns user if not the case (except for Google Colab where "store" is set by default
+    by `huggingface_hub`).
+    """
+    helpers = list_credential_helpers()
+    if len(helpers) > 0:
+        return True  # Do not warn: at least 1 helper is set
+
+    # Only in Google Colab to avoid the warning message
+    # See https://github.com/huggingface/huggingface_hub/issues/1043#issuecomment-1247010710
+    if is_google_colab():
+        _set_store_as_git_credential_helper_globally()
+        return True  # Do not warn: "store" is used by default in Google Colab
+
+    # Otherwise, warn user
+    print(
+        ANSI.red(
+            "Cannot authenticate through git-credential as no helper is defined on your"
+            " machine.\nYou might have to re-authenticate when pushing to the Hugging"
+            " Face Hub.\nRun the following command in your terminal in case you want to"
+            " set the 'store' credential helper as default.\n\ngit config --global"
+            " credential.helper store\n\nRead"
+            " https://git-scm.com/book/en/v2/Git-Tools-Credential-Storage for more"
+            " details."
+        )
+    )
+    return False
+
+
+def _set_store_as_git_credential_helper_globally() -> None:
+    """Set globally the credential.helper to `store`.
+
+    To be used only in Google Colab as we assume the user doesn't care about the git
+    credential config. It is the only particular case where we don't want to display the
+    warning message in [`notebook_login()`].
+
+    Related:
+    - https://github.com/huggingface/huggingface_hub/issues/1043
+    - https://github.com/huggingface/huggingface_hub/issues/1051
+    - https://git-scm.com/docs/git-credential-store
+    """
+    try:
+        run_subprocess("git config --global credential.helper store")
+    except subprocess.CalledProcessError as exc:
+        raise OSError(exc.stderr)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oauth.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oauth.py
new file mode 100644
index 0000000000000000000000000000000000000000..cac82ada87262370031740ea6d7c9234aec44de0
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oauth.py
@@ -0,0 +1,460 @@
+import datetime
+import hashlib
+import logging
+import os
+import time
+import urllib.parse
+import warnings
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Literal
+
+from . import constants
+from .hf_api import whoami
+from .utils import experimental, get_token
+
+
+logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    import fastapi
+
+
+@dataclass
+class OAuthOrgInfo:
+    """
+    Information about an organization linked to a user logged in with OAuth.
+
+    Attributes:
+        sub (`str`):
+            Unique identifier for the org. OpenID Connect field.
+        name (`str`):
+            The org's full name. OpenID Connect field.
+        preferred_username (`str`):
+            The org's username. OpenID Connect field.
+        picture (`str`):
+            The org's profile picture URL. OpenID Connect field.
+        plan (`str`, *optional*):
+            The org's plan (e.g., "enterprise", "team"). Hugging Face field.
+        can_pay (`Optional[bool]`, *optional*):
+            Whether the org has a payment method set up. Hugging Face field.
+        role_in_org (`Optional[str]`, *optional*):
+            The user's role in the org. Hugging Face field.
+        security_restrictions (`Optional[list[Literal["ip", "token-policy", "mfa", "sso"]]]`, *optional*):
+            Array of security restrictions that the user hasn't completed for this org. Possible values: "ip", "token-policy", "mfa", "sso". Hugging Face field.
+    """
+
+    sub: str
+    name: str
+    preferred_username: str
+    picture: str
+    plan: str | None = None
+    can_pay: bool | None = None
+    role_in_org: str | None = None
+    security_restrictions: list[Literal["ip", "token-policy", "mfa", "sso"]] | None = None
+
+
+@dataclass
+class OAuthUserInfo:
+    """
+    Information about a user logged in with OAuth.
+
+    Attributes:
+        sub (`str`):
+            Unique identifier for the user, even in case of rename. OpenID Connect field.
+        name (`str`):
+            The user's full name. OpenID Connect field.
+        preferred_username (`str`):
+            The user's username. OpenID Connect field.
+        email_verified (`Optional[bool]`, *optional*):
+            Indicates if the user's email is verified. OpenID Connect field.
+        email (`Optional[str]`, *optional*):
+            The user's email address. OpenID Connect field.
+        picture (`str`):
+            The user's profile picture URL. OpenID Connect field.
+        profile (`str`):
+            The user's profile URL. OpenID Connect field.
+        website (`Optional[str]`, *optional*):
+            The user's website URL. OpenID Connect field.
+        is_pro (`bool`):
+            Whether the user is a pro user. Hugging Face field.
+        can_pay (`Optional[bool]`, *optional*):
+            Whether the user has a payment method set up. Hugging Face field.
+        orgs (`Optional[list[OrgInfo]]`, *optional*):
+            List of organizations the user is part of. Hugging Face field.
+    """
+
+    sub: str
+    name: str
+    preferred_username: str
+    email_verified: bool | None
+    email: str | None
+    picture: str
+    profile: str
+    website: str | None
+    is_pro: bool
+    can_pay: bool | None
+    orgs: list[OAuthOrgInfo] | None
+
+
+@dataclass
+class OAuthInfo:
+    """
+    Information about the OAuth login.
+
+    Attributes:
+        access_token (`str`):
+            The access token.
+        access_token_expires_at (`datetime.datetime`):
+            The expiration date of the access token.
+        user_info ([`OAuthUserInfo`]):
+            The user information.
+        state (`str`, *optional*):
+            State passed to the OAuth provider in the original request to the OAuth provider.
+        scope (`str`):
+            Granted scope.
+    """
+
+    access_token: str
+    access_token_expires_at: datetime.datetime
+    user_info: OAuthUserInfo
+    state: str | None
+    scope: str
+
+
+@experimental
+def attach_huggingface_oauth(app: "fastapi.FastAPI", route_prefix: str = "/"):
+    """
+    Add OAuth endpoints to a FastAPI app to enable OAuth login with Hugging Face.
+
+    How to use:
+    - Call this method on your FastAPI app to add the OAuth endpoints.
+    - Inside your route handlers, call `parse_huggingface_oauth(request)` to retrieve the OAuth info.
+    - If user is logged in, an [`OAuthInfo`] object is returned with the user's info. If not, `None` is returned.
+    - In your app, make sure to add links to `/oauth/huggingface/login` and `/oauth/huggingface/logout` for the user to log in and out.
+
+    Example:
+    ```py
+    from huggingface_hub import attach_huggingface_oauth, parse_huggingface_oauth
+
+    # Create a FastAPI app
+    app = FastAPI()
+
+    # Add OAuth endpoints to the FastAPI app
+    attach_huggingface_oauth(app)
+
+    # Add a route that greets the user if they are logged in
+    @app.get("/")
+    def greet_json(request: Request):
+        # Retrieve the OAuth info from the request
+        oauth_info = parse_huggingface_oauth(request)  # e.g. OAuthInfo dataclass
+        if oauth_info is None:
+            return {"msg": "Not logged in!"}
+        return {"msg": f"Hello, {oauth_info.user_info.preferred_username}!"}
+    ```
+    """
+    # TODO: handle generic case (handling OAuth in a non-Space environment with custom dev values) (low priority)
+
+    # Add SessionMiddleware to the FastAPI app to store the OAuth info in the session.
+    # Session Middleware requires a secret key to sign the cookies. Let's use a hash
+    # of the OAuth secret key to make it unique to the Space + updated in case OAuth
+    # config gets updated. When ran locally, we use an empty string as a secret key.
+    try:
+        from starlette.middleware.sessions import SessionMiddleware
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file in order to install the required dependencies."
+        ) from e
+    session_secret = (constants.OAUTH_CLIENT_SECRET or "") + "-v1"
+    app.add_middleware(
+        SessionMiddleware,  # type: ignore
+        secret_key=hashlib.sha256(session_secret.encode()).hexdigest(),
+        same_site="none",
+        https_only=True,
+    )  # type: ignore
+
+    # Add OAuth endpoints to the FastAPI app:
+    #   - {route_prefix}/oauth/huggingface/login
+    #   - {route_prefix}/oauth/huggingface/callback
+    #   - {route_prefix}/oauth/huggingface/logout
+    # If the app is running in a Space, OAuth is enabled normally.
+    # Otherwise, we mock the endpoints to make the user log in with a fake user profile - without any calls to hf.co.
+    route_prefix = route_prefix.strip("/")
+    if os.getenv("SPACE_ID") is not None:
+        logger.info("OAuth is enabled in the Space. Adding OAuth routes.")
+        _add_oauth_routes(app, route_prefix=route_prefix)
+    else:
+        logger.info("App is not running in a Space. Adding mocked OAuth routes.")
+        _add_mocked_oauth_routes(app, route_prefix=route_prefix)
+
+
+def parse_huggingface_oauth(request: "fastapi.Request") -> OAuthInfo | None:
+    """
+    Returns the information from a logged-in user as a [`OAuthInfo`] object.
+
+    For flexibility and future-proofing, this method is very lax in its parsing and does not raise errors.
+    Missing fields are set to `None` without a warning.
+
+    Return `None`, if the user is not logged in (no info in session cookie).
+
+    See [`attach_huggingface_oauth`] for an example on how to use this method.
+    """
+    if "oauth_info" not in request.session:
+        logger.debug("No OAuth info in session.")
+        return None
+
+    logger.debug("Parsing OAuth info from session.")
+    oauth_data = request.session["oauth_info"]
+    user_data = oauth_data.get("userinfo", {})
+    orgs_data = user_data.get("orgs", [])
+
+    orgs = (
+        [
+            OAuthOrgInfo(
+                sub=org.get("sub"),
+                name=org.get("name"),
+                preferred_username=org.get("preferred_username"),
+                picture=org.get("picture"),
+                plan=org.get("plan"),
+                can_pay=org.get("canPay"),
+                role_in_org=org.get("roleInOrg"),
+                security_restrictions=org.get("securityRestrictions"),
+            )
+            for org in orgs_data
+        ]
+        if orgs_data
+        else None
+    )
+
+    user_info = OAuthUserInfo(
+        sub=user_data.get("sub"),
+        name=user_data.get("name"),
+        preferred_username=user_data.get("preferred_username"),
+        email_verified=user_data.get("email_verified"),
+        email=user_data.get("email"),
+        picture=user_data.get("picture"),
+        profile=user_data.get("profile"),
+        website=user_data.get("website"),
+        is_pro=user_data.get("isPro"),
+        can_pay=user_data.get("canPay"),
+        orgs=orgs,
+    )
+
+    return OAuthInfo(
+        access_token=oauth_data.get("access_token"),
+        access_token_expires_at=datetime.datetime.fromtimestamp(oauth_data.get("expires_at")),
+        user_info=user_info,
+        state=oauth_data.get("state"),
+        scope=oauth_data.get("scope"),
+    )
+
+
+def _add_oauth_routes(app: "fastapi.FastAPI", route_prefix: str) -> None:
+    """Add OAuth routes to the FastAPI app (login, callback handler and logout)."""
+    try:
+        import fastapi
+        from authlib.integrations.base_client.errors import MismatchingStateError
+        from authlib.integrations.starlette_client import OAuth
+        from fastapi.responses import RedirectResponse
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file."
+        ) from e
+
+    # Check environment variables
+    msg = (
+        "OAuth is required but '{}' environment variable is not set. Make sure you've enabled OAuth in your Space by"
+        " setting `hf_oauth: true` in the Space metadata."
+    )
+    if constants.OAUTH_CLIENT_ID is None:
+        raise ValueError(msg.format("OAUTH_CLIENT_ID"))
+    if constants.OAUTH_CLIENT_SECRET is None:
+        raise ValueError(msg.format("OAUTH_CLIENT_SECRET"))
+    if constants.OAUTH_SCOPES is None:
+        raise ValueError(msg.format("OAUTH_SCOPES"))
+    if constants.OPENID_PROVIDER_URL is None:
+        raise ValueError(msg.format("OPENID_PROVIDER_URL"))
+
+    # Register OAuth server
+    oauth = OAuth()
+    oauth.register(
+        name="huggingface",
+        client_id=constants.OAUTH_CLIENT_ID,
+        client_secret=constants.OAUTH_CLIENT_SECRET,
+        client_kwargs={"scope": constants.OAUTH_SCOPES},
+        server_metadata_url=constants.OPENID_PROVIDER_URL + "/.well-known/openid-configuration",
+    )
+
+    login_uri, callback_uri, logout_uri = _get_oauth_uris(route_prefix)
+
+    # Register OAuth endpoints
+    @app.get(login_uri)
+    async def oauth_login(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that redirects to HF OAuth page."""
+        redirect_uri = _generate_redirect_uri(request)
+        return await oauth.huggingface.authorize_redirect(request, redirect_uri)  # type: ignore
+
+    @app.get(callback_uri)
+    async def oauth_redirect_callback(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that handles the OAuth callback."""
+        try:
+            oauth_info = await oauth.huggingface.authorize_access_token(request)  # type: ignore
+        except MismatchingStateError:
+            # Parse query params
+            nb_redirects = int(request.query_params.get("_nb_redirects", 0))
+            target_url = request.query_params.get("_target_url")
+
+            # Build redirect URI with the same query params as before and bump nb_redirects count
+            query_params: dict[str, int | str] = {"_nb_redirects": nb_redirects + 1}
+            if target_url:
+                query_params["_target_url"] = target_url
+
+            redirect_uri = f"{login_uri}?{urllib.parse.urlencode(query_params)}"
+
+            # If the user is redirected more than 3 times, it is very likely that the cookie is not working properly.
+            # (e.g. browser is blocking third-party cookies in iframe). In this case, redirect the user in the
+            # non-iframe view.
+            if nb_redirects > constants.OAUTH_MAX_REDIRECTS:
+                host = os.environ.get("SPACE_HOST")
+                if host is None:  # cannot happen in a Space
+                    raise RuntimeError(
+                        "App is not running in a Space (SPACE_HOST environment variable is not set). Cannot redirect to non-iframe view."
+                    ) from None
+                host_url = "https://" + host.rstrip("/")
+                return RedirectResponse(host_url + redirect_uri)
+
+            # Redirect the user to the login page again
+            return RedirectResponse(redirect_uri)
+
+        # OAuth login worked => store the user info in the session and redirect
+        logger.debug("Successfully logged in with OAuth. Storing user info in session.")
+        request.session["oauth_info"] = oauth_info
+        return RedirectResponse(_get_redirect_target(request))
+
+    @app.get(logout_uri)
+    async def oauth_logout(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that logs out the user (e.g. delete info from cookie session)."""
+        logger.debug("Logged out with OAuth. Removing user info from session.")
+        request.session.pop("oauth_info", None)
+        return RedirectResponse(_get_redirect_target(request))
+
+
+def _add_mocked_oauth_routes(app: "fastapi.FastAPI", route_prefix: str = "/") -> None:
+    """Add fake oauth routes if app is run locally and OAuth is enabled.
+
+    Using OAuth will have the same behavior as in a Space but instead of authenticating with HF, a mocked user profile
+    is added to the session.
+    """
+    try:
+        import fastapi
+        from fastapi.responses import RedirectResponse
+        from starlette.datastructures import URL
+    except ImportError as e:
+        raise ImportError(
+            "Cannot initialize OAuth to due a missing library. Please run `pip install huggingface_hub[oauth]` or add "
+            "`huggingface_hub[oauth]` to your requirements.txt file."
+        ) from e
+
+    warnings.warn(
+        "OAuth is not supported outside of a Space environment. To help you debug your app locally, the oauth endpoints"
+        " are mocked to return your profile and token. To make it work, your machine must be logged in to Huggingface."
+    )
+    mocked_oauth_info = _get_mocked_oauth_info()
+
+    login_uri, callback_uri, logout_uri = _get_oauth_uris(route_prefix)
+
+    # Define OAuth routes
+    @app.get(login_uri)
+    async def oauth_login(request: fastapi.Request) -> RedirectResponse:
+        """Fake endpoint that redirects to HF OAuth page."""
+        # Define target (where to redirect after login)
+        redirect_uri = _generate_redirect_uri(request)
+        return RedirectResponse(callback_uri + "?" + urllib.parse.urlencode({"_target_url": redirect_uri}))
+
+    @app.get(callback_uri)
+    async def oauth_redirect_callback(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that handles the OAuth callback."""
+        request.session["oauth_info"] = mocked_oauth_info
+        return RedirectResponse(_get_redirect_target(request))
+
+    @app.get(logout_uri)
+    async def oauth_logout(request: fastapi.Request) -> RedirectResponse:
+        """Endpoint that logs out the user (e.g. delete cookie session)."""
+        request.session.pop("oauth_info", None)
+        logout_url = URL("/").include_query_params(**request.query_params)
+        return RedirectResponse(url=logout_url, status_code=302)  # see https://github.com/gradio-app/gradio/pull/9659
+
+
+def _generate_redirect_uri(request: "fastapi.Request") -> str:
+    if "_target_url" in request.query_params:
+        # if `_target_url` already in query params => respect it
+        target = request.query_params["_target_url"]
+    else:
+        # otherwise => keep query params
+        target = "/?" + urllib.parse.urlencode(request.query_params)
+
+    redirect_uri = request.url_for("oauth_redirect_callback").include_query_params(_target_url=target)
+    redirect_uri_as_str = str(redirect_uri)
+    if redirect_uri.netloc.endswith(".hf.space"):
+        # In Space, FastAPI redirect as http but we want https
+        redirect_uri_as_str = redirect_uri_as_str.replace("http://", "https://")
+    return redirect_uri_as_str
+
+
+def _get_redirect_target(request: "fastapi.Request", default_target: str = "/") -> str:
+    return request.query_params.get("_target_url", default_target)
+
+
+def _get_mocked_oauth_info() -> dict:
+    token = get_token()
+    if token is None:
+        raise ValueError(
+            "Your machine must be logged in to HF to debug an OAuth app locally. Please"
+            " run `hf auth login` or set `HF_TOKEN` as environment variable "
+            "with one of your access token. You can generate a new token in your "
+            "settings page (https://huggingface.co/settings/tokens)."
+        )
+
+    user = whoami()
+    if user["type"] != "user":
+        raise ValueError(
+            "Your machine is not logged in with a personal account. Please use a "
+            "personal access token. You can generate a new token in your settings page"
+            " (https://huggingface.co/settings/tokens)."
+        )
+
+    return {
+        "access_token": token,
+        "token_type": "bearer",
+        "expires_in": 8 * 60 * 60,  # 8 hours
+        "id_token": "FOOBAR",
+        "scope": "openid profile",
+        "refresh_token": "hf_oauth__refresh_token",
+        "expires_at": int(time.time()) + 8 * 60 * 60,  # 8 hours
+        "userinfo": {
+            "sub": "0123456789",
+            "name": user["fullname"],
+            "preferred_username": user["name"],
+            "profile": f"https://huggingface.co/{user['name']}",
+            "picture": user["avatarUrl"],
+            "website": "",
+            "aud": "00000000-0000-0000-0000-000000000000",
+            "auth_time": 1691672844,
+            "nonce": "aaaaaaaaaaaaaaaaaaa",
+            "iat": 1691672844,
+            "exp": 1691676444,
+            "iss": "https://huggingface.co",
+        },
+    }
+
+
+def _get_oauth_uris(route_prefix: str = "/") -> tuple[str, str, str]:
+    route_prefix = route_prefix.strip("/")
+    if route_prefix:
+        route_prefix = f"/{route_prefix}"
+    return (
+        f"{route_prefix}/oauth/huggingface/login",
+        f"{route_prefix}/oauth/huggingface/callback",
+        f"{route_prefix}/oauth/huggingface/logout",
+    )
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oidc.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oidc.py
new file mode 100644
index 0000000000000000000000000000000000000000..3a7dba20418a2ece15afa5b5c1cbc127eb8f32cd
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_oidc.py
@@ -0,0 +1,163 @@
+# Copyright 2026 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.
+"""Keyless CI/CD authentication via OIDC token exchange ("Trusted Publishers").
+
+A CI job proves its identity to the Hub with a short-lived OIDC id token minted by its CI
+provider (e.g. GitHub Actions), then exchanges it at ``POST {ENDPOINT}/oauth/token`` (RFC 8693)
+for a short-lived Hugging Face token — no long-lived ``HF_TOKEN`` secret to store.
+
+This module is self-contained: it only handles minting the provider id token and the exchange.
+It deliberately does not register a public API or a CLI verb; the integration point is the token
+resolution in ``utils/_auth.py`` (see ``_get_token_from_oidc``).
+
+Docs: https://huggingface.co/docs/hub/trusted-publishers
+"""
+
+import os
+from enum import Enum
+
+from . import constants
+from .errors import OIDCError
+from .utils import get_session, hf_raise_for_status
+
+
+# RFC 8693 token-exchange grant + id-token subject type (see trusted-publishers docs).
+_TOKEN_EXCHANGE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:token-exchange"
+_ID_TOKEN_TYPE = "urn:ietf:params:oauth:token-type:id_token"
+
+
+class Provider(str, Enum):
+    """CI providers that can mint an OIDC id token natively. GitHub Actions only for now."""
+
+    GITHUB = "github"
+
+
+def detect_provider() -> Provider | None:
+    """Detect the CI provider able to mint an OIDC id token, or `None` if not in a supported CI."""
+    if os.environ.get("GITHUB_ACTIONS") == "true":
+        return Provider.GITHUB
+    return None
+
+
+def _get_github_oidc_token(audience: str) -> str:
+    """Mint an OIDC id token from the GitHub Actions runtime.
+
+    Relies on the `ACTIONS_ID_TOKEN_REQUEST_URL` / `ACTIONS_ID_TOKEN_REQUEST_TOKEN` env vars,
+    which GitHub only injects when the job declares `permissions: id-token: write`.
+    """
+    request_url = os.environ.get("ACTIONS_ID_TOKEN_REQUEST_URL")
+    request_token = os.environ.get("ACTIONS_ID_TOKEN_REQUEST_TOKEN")
+    if not request_url or not request_token:
+        raise OIDCError(
+            "Cannot request an OIDC id token from GitHub Actions. Make sure the workflow job sets "
+            "`permissions: id-token: write`. See "
+            "https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect"
+        )
+    response = get_session().get(
+        request_url,
+        params={"audience": audience},
+        headers={"Authorization": f"Bearer {request_token}"},
+    )
+    hf_raise_for_status(response)
+    return response.json()["value"]
+
+
+def get_oidc_token(*, provider: Provider | str | None = None, audience: str | None = None) -> str:
+    """Mint a raw OIDC id token (JWT) from the current CI provider.
+
+    Args:
+        provider (`str`, *optional*):
+            CI provider to use. Auto-detected from the environment when omitted.
+        audience (`str`, *optional*):
+            The `aud` claim to request. Defaults to `constants.ENDPOINT` so it matches the endpoint
+            that validates it (respects `HF_ENDPOINT`/staging).
+
+    Returns:
+        `str`: The raw id token (JWT) to pass to [`exchange_oidc_token`].
+    """
+    audience = audience or constants.ENDPOINT
+    provider = provider or detect_provider()
+    supported = ", ".join(p.value for p in Provider)
+    if provider is None:
+        raise OIDCError(f"No supported CI OIDC provider detected. Trusted Publishers currently supports: {supported}.")
+    if provider == Provider.GITHUB:
+        return _get_github_oidc_token(audience)
+    raise NotImplementedError(f"OIDC provider '{provider}' is not supported yet. Supported: {supported}.")
+
+
+def exchange_oidc_token(*, subject_token: str, resource: str, endpoint: str | None = None) -> dict:
+    """Exchange a CI OIDC id token for a short-lived Hugging Face token (RFC 8693).
+
+    Args:
+        subject_token (`str`):
+            The raw OIDC id token (JWT) from the CI provider. Its `aud` claim must be the Hub URL.
+        resource (`str`):
+            What to scope the token to: a Hub repo (`namespace/name`, `datasets/namespace/name`,
+            `spaces/namespace/name`, `kernels/namespace/name`) for a write token, or a bare Hub
+            username for a read-only `gated-repos` token.
+        endpoint (`str`, *optional*):
+            Hub endpoint. Defaults to `constants.ENDPOINT` (respects `HF_ENDPOINT`/staging).
+
+    Returns:
+        `dict`: The token-exchange response, e.g.
+        `{"access_token": "hf_jwt_…", "token_type": "bearer", "expires_in": 3600, ...}`.
+    """
+    response = get_session().post(
+        f"{endpoint or constants.ENDPOINT}/oauth/token",
+        json={
+            "grant_type": _TOKEN_EXCHANGE_GRANT_TYPE,
+            "subject_token_type": _ID_TOKEN_TYPE,
+            "subject_token": subject_token,
+            "resource": resource,
+        },
+    )
+    hf_raise_for_status(response)
+    return response.json()
+
+
+def oidc_login(
+    *,
+    resource: str,
+    subject_token: str | None = None,
+    provider: Provider | str | None = None,
+    audience: str | None = None,
+    endpoint: str | None = None,
+) -> dict:
+    """Mint a CI OIDC id token and exchange it for a Hugging Face token.
+
+    Convenience wrapper around [`get_oidc_token`] + [`exchange_oidc_token`]. Returns the raw
+    exchange response (it does not persist anything — the caller decides what to do with the token).
+
+    Args:
+        resource (`str`):
+            Repo or username to scope the token to. See [`exchange_oidc_token`].
+        subject_token (`str`, *optional*):
+            A pre-minted OIDC id token to exchange directly. Use this for CI providers not yet
+            supported natively (e.g. GitLab): mint the id token in your job and pass it here. When
+            omitted, the token is minted from the detected `provider`.
+        provider (`str`, *optional*):
+            CI provider. Auto-detected when omitted. Ignored when `subject_token` is provided.
+        audience (`str`, *optional*):
+            The `aud` claim to request. Defaults to the resolved `endpoint`, so it matches the
+            endpoint that validates it.
+        endpoint (`str`, *optional*):
+            Hub endpoint. Defaults to `constants.ENDPOINT`.
+
+    Returns:
+        `dict`: The token-exchange response (`access_token`, `token_type`, `expires_in`, ...).
+    """
+    endpoint = endpoint or constants.ENDPOINT
+    if subject_token is None:
+        subject_token = get_oidc_token(provider=provider, audience=audience or endpoint)
+    return exchange_oidc_token(subject_token=subject_token, resource=resource, endpoint=endpoint)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_revision.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_revision.py
new file mode 100644
index 0000000000000000000000000000000000000000..c7b96d94b7a95e88be60e90a553219177425ac12
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_revision.py
@@ -0,0 +1,62 @@
+from . import constants
+
+
+class ResolvedRevision(str):
+    """A git revision that has already been resolved to a commit hash.
+
+    `ResolvedRevision` is a `str` subclass, so it can be passed to any `huggingface_hub` method taking a `revision`
+    argument. Its string value is the revision initially requested by the user (e.g. `"main"`, `"refs/pr/4"`),
+    which keeps URLs and error messages readable, while `.resolved` holds the commit hash it points to.
+
+    Instances are built by [`HfApi.resolve_revision`], which also caches the `revision` -> `commit hash` mapping
+    in the local cache (`refs/` folder).
+
+    A commit hash only means something for the repo it was resolved against, so an instance also remembers that
+    repo. Re-resolving it for another repo is not an error: the revision initially requested is resolved again
+    (see [`HfApi.resolve_revision`]).
+
+    Attributes:
+        initial (`str` or `None`):
+            The revision initially requested by the user. If `None`, the string value defaults to `"main"`.
+        resolved (`str`):
+            The commit hash that `initial` resolves to.
+
+    Example:
+    ```python
+    >>> from huggingface_hub import resolve_revision
+    >>> revision = resolve_revision("openai-community/gpt2")
+    >>> revision
+    ResolvedRevision(initial=None, resolved='607a30d783dfa663caf39e06633721c8d4cfcd7e')
+    >>> revision == "main"  # it's a string
+    True
+    >>> revision.resolved
+    '607a30d783dfa663caf39e06633721c8d4cfcd7e'
+    ```
+    """
+
+    initial: str | None
+    resolved: str
+    _repo_id: str | None
+    _repo_type: str
+
+    def __new__(
+        cls,
+        resolved: str,
+        initial: str | None = None,
+        repo_id: str | None = None,
+        repo_type: str | None = None,
+    ) -> "ResolvedRevision":
+        revision = super().__new__(cls, initial if initial is not None else constants.DEFAULT_REVISION)
+        revision.initial = initial
+        revision.resolved = resolved
+        # The repo `resolved` belongs to. `None` means unknown, in which case it is assumed to fit any repo.
+        revision._repo_id = repo_id
+        revision._repo_type = repo_type or constants.REPO_TYPE_MODEL
+        return revision
+
+    def __reduce__(self):
+        # without this, pickle/copy rebuild the instance from its string value only, losing the attributes
+        return self.__class__, (self.resolved, self.initial, self._repo_id, self._repo_type)
+
+    def __repr__(self) -> str:
+        return f"ResolvedRevision(initial={self.initial!r}, resolved={self.resolved!r})"
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox.py
new file mode 100644
index 0000000000000000000000000000000000000000..d108c570f9f705a9313e188eb4d7864c0866c1ca
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox.py
@@ -0,0 +1,2588 @@
+# coding=utf-8
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import hashlib
+import hmac
+import json
+import os
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from secrets import token_hex
+from typing import Any, BinaryIO, Callable, Iterator, List, Literal, overload
+from urllib.parse import urlparse
+
+import httpx2
+
+from . import constants
+from ._sandbox_cache import (
+    HOST_TRUST_TTL,
+    CacheContext,
+    CachedHost,
+    delete_pool_cache,
+    read_pool_cache,
+    save_pool_cache,
+)
+from ._space_api import Volume
+from .errors import HfHubHTTPError, SandboxCommandError, SandboxError
+from .hf_api import HfApi, JobInfo
+from .utils import get_token, logging
+from .utils._parsing import parse_duration
+
+
+logger = logging.get_logger(__name__)
+
+# Port the sandbox server listens on inside the job. Deliberately uncommon so that typical user ports stay free.
+SANDBOX_SERVER_PORT = 49983
+
+# Stable marker present on every sandbox job to ease filtering
+SANDBOX_LABEL = "hf-sandbox"
+# Sandbox mode: "dedicated" or "pool" to ease filtering
+MODE_LABEL = "hf-sandbox-mode"
+MODE_DEDICATED = "dedicated"
+MODE_POOL = "pool"
+# Pool name, to scope host reuse to a named group (see SandboxPool(name=...)). Present on pool
+# host jobs only. Pool config (capacity, idle timeout) lives in the host's env vars, read via
+# inspect_job — labels are kept for filtering/grouping only.
+POOL_LABEL = "hf-sandbox-pool"
+# Per-job public nonce the sandbox token is derived from (see _derive_sandbox_token), so
+# `Sandbox.connect(id)` can recompute the token from any machine with no local state.
+NONCE_LABEL = "hf-sandbox-nonce"
+
+RESERVED_SANDBOX_LABELS = frozenset({SANDBOX_LABEL, MODE_LABEL, POOL_LABEL, NONCE_LABEL})
+
+DEFAULT_IMAGE = "python:3.12"
+
+# The exact sbx-server build every sandbox job downloads and runs as root, pinned by digest.
+# The bucket object is fetched by its sha256 name and the download is verified before it is
+# made executable (see `_BOOTSTRAP_DOWNLOAD`), so the bytes that run are the bytes that were
+# reviewed for this release -- not whatever the mutable `sbx-server` alias points at today.
+# Both constants move together on every server release; the digest is printed by the server
+# repo's publish workflow.
+SANDBOX_SERVER_VERSION = "0.7.0"
+SANDBOX_SERVER_SHA256 = "eb2b04f79fbe765195300aaf1582be2a2a9ea698ff067d0cab428171d5584932"
+
+# The sbx-server wire contract this client drives, checked against `/health`'s `protocol` on
+# startup. A pool host keeps the binary it downloaded at boot for up to 24h, so pinning a
+# digest does not stop this client from meeting a server it did not pin -- the check does.
+SANDBOX_SERVER_PROTOCOL = 3
+
+DEFAULT_IDLE_TIMEOUT = 10 * 60  # 10 minutes
+SANDBOX_MAX_LIFETIME = "24h"
+
+DEFAULT_SANDBOXES_PER_HOST = 50
+
+# How long `close()` waits for in-flight creates before giving up on them. A
+# wedged create must not hang process exit, but returning immediately would let
+# a host it is still booting escape teardown.
+_CLOSE_DRAIN_TIMEOUT = 30.0
+
+# Ceiling on the output `run()` will accumulate for its result. Without one, a
+# runaway command (a loop printing to stdout, say) is an unbounded allocation in
+# the caller's process -- and it happened even when a callback was already
+# consuming the output. Raising beats being OOM-killed with no explanation.
+MAX_CAPTURED_OUTPUT_CHARS = 64 * 1024 * 1024
+
+# Which pool hosts `create()` may adopt from job labels. Labels are set by whoever
+# creates a Job, so "any job carrying our pool's labels" is not an identity claim --
+# see the `adopt_hosts` argument of [`SandboxPool`].
+ADOPT_OWN = "own"
+ADOPT_NAMESPACE = "namespace"
+ADOPT_NEVER = "never"
+
+SHARED_ID_SEP = "."
+
+# Job stages in which a sandbox/host is finished and needs no teardown.
+_TERMINAL_STAGES = ("COMPLETED", "ERROR", "DELETED", "CANCELED")
+
+# Safety bound on create()'s pack-retry loop
+_MAX_PACK_ROUNDS = 8
+
+# hf-mount path where the server bucket is mounted on every sandbox job
+_SERVER_MOUNT_PATH = "/.hf-sbx-server"
+
+# Job startup script (needs only /bin/sh). The server bucket is public, so the download is
+# unauthenticated: no HF credential is ever placed in the job environment (see `_derive_sandbox_token`).
+#
+# It fetches a public object and runs it as root, as PID 1, holding the sandbox token -- so it
+# checks the bytes against `SANDBOX_SERVER_SHA256` and refuses to run them if they don't match.
+# The check happens *before* `chmod +x`: an unverified file that is already executable is one
+# slip away from being executed. Neither `sha256sum` nor `openssl` is guaranteed to exist in an
+# arbitrary image, so both are tried; with neither, the default is to refuse rather than to run
+# unverified code, and `SBX_ALLOW_UNVERIFIED_SERVER=1` (dedicated job `env=` or the image environment) is the way out for an
+# image that has to. It never bypasses a *failed* check, only a missing tool.
+_BOOTSTRAP_DOWNLOAD = """\
+set -e
+d=/tmp/.sbx-server
+if command -v wget >/dev/null 2>&1; then wget -q -O "$d" "$SBX_SERVER_URL"
+elif command -v curl >/dev/null 2>&1; then curl -fsSL -o "$d" "$SBX_SERVER_URL"
+else cp "$SBX_SERVER_MOUNT/sbx-server-$SBX_SERVER_SHA256" "$d"; fi
+if command -v sha256sum >/dev/null 2>&1; then
+  actual=$(sha256sum "$d" | cut -d' ' -f1)
+elif command -v openssl >/dev/null 2>&1; then
+  actual=$(openssl dgst -sha256 -r "$d" | cut -d' ' -f1)
+elif [ "${SBX_ALLOW_UNVERIFIED_SERVER:-}" = 1 ]; then
+  echo "sbx: SBX_ALLOW_UNVERIFIED_SERVER=1: running the sandbox server unverified" >&2
+  actual=$SBX_SERVER_SHA256  # opted out, so there is nothing left to compare against
+else
+  echo "sbx: cannot verify the sandbox server digest: this image has neither sha256sum nor" >&2
+  echo "sbx: openssl, so refusing to run it. Use an image with either hash tool installed." >&2
+  echo "sbx: Dedicated jobs may opt out with env={'SBX_ALLOW_UNVERIFIED_SERVER': '1'};" >&2
+  echo "sbx: pool hosts require setting it in the image environment instead." >&2
+  exit 1
+fi
+if [ "$actual" != "$SBX_SERVER_SHA256" ]; then
+  echo "sbx: sandbox server digest mismatch: got $actual," >&2
+  echo "sbx: expected $SBX_SERVER_SHA256." >&2
+  echo "sbx: refusing to run it. Upgrade huggingface_hub if this client is pinned to a" >&2
+  echo "sbx: digest that is no longer published." >&2
+  exit 1
+fi
+chmod +x "$d"
+unset SBX_SERVER_URL SBX_SERVER_MOUNT SBX_SERVER_SHA256 SBX_ALLOW_UNVERIFIED_SERVER
+exec "$d"
+"""
+
+
+def _derive_sandbox_token(hf_token: str, nonce: str) -> str:
+    """Derive the sandbox auth token from the user's HF token and the job's nonce.
+
+    Stateless: any machine holding the same HF token can recompute it from the
+    nonce stored in the job's labels, so `Sandbox.connect(job_id)` needs no local state.
+    Only the derived token is passed to the sandbox server as a job secret; the HF token
+    itself is not.
+
+    Scope: one nonce is minted per *job*, not per sandbox. For a dedicated sandbox those are
+    the same thing. In a pool this derives the *host* credential, which manages the pool and
+    can recover per-sandbox tokens -- a leak there is host-wide. Each pooled sandbox also has
+    its own random capability token, minted by the host server, which is what per-sandbox
+    operations and `proxy_headers` use.
+
+    This is not a hardened boundary in either direction. An untrusted image can own the
+    sandbox port, so don't treat it as a guarantee that credentials stay out of the sandbox;
+    and the token is derived for whichever job carries the matching nonce label, so don't
+    treat holding it as proof of which job you are talking to.
+    """
+    return hmac.new(hf_token.encode(), f"hf-sandbox:{nonce}".encode(), hashlib.sha256).hexdigest()
+
+
+def _duration_to_secs(duration: int | float | str) -> int:
+    """Parse a duration like 300, "300s", "10m", "2h", "1d" into seconds."""
+    if isinstance(duration, (int, float)):
+        return int(duration)
+    return parse_duration(duration)
+
+
+@dataclass
+class SandboxCommandResult:
+    """Result of a command executed in a sandbox with [`Sandbox.run`]."""
+
+    exit_code: int | None
+    stdout: str
+    stderr: str
+    signal: int | None = None
+    timed_out: bool = False
+    duration_ms: int = 0
+
+    @property
+    def ok(self) -> bool:
+        return self.exit_code == 0
+
+    def __repr__(self) -> str:
+        out = self.stdout if len(self.stdout) <= 80 else self.stdout[:77] + "..."
+        return f"SandboxCommandResult(exit_code={self.exit_code}, stdout={out!r}, duration_ms={self.duration_ms})"
+
+
+@dataclass
+class SandboxProcess:
+    """A background process started in a sandbox with [`Sandbox.run`]`(..., background=True)`.
+
+    List a sandbox's processes with [`Sandbox.processes`] and stop one with [`SandboxProcess.kill`].
+    Recently completed processes stay in the listing (the server keeps a bounded number of
+    them), so `running` and `exit_code` tell whether a process is still alive or already
+    exited (as of when it was listed).
+    """
+
+    # Server-assigned handle, and the only identifier that addresses this process.
+    # `pid` is the OS pid: useful for correlating with `ps` inside the sandbox, but
+    # the OS may reuse it, so it is observational only. `None` for a process on a
+    # host running a server that predates opaque ids.
+    id: str | None
+    pid: int
+    cmd: str | List[str]
+    # Back-reference to the sandbox, used by `kill()`. Excluded from repr/eq so a process
+    # stays a plain data object.
+    _sandbox: "Sandbox" = field(repr=False, compare=False)
+    tag: str | None = None
+    started_at_ms: int | None = None
+    running: bool = True
+    exit_code: int | None = None
+
+    def kill(self) -> bool:
+        """Terminate the background process. Idempotent.
+
+        Returns whether this call is what stopped it: `False` means it had already
+        exited or been terminated, which is not an error.
+
+        Note that a descendant which detaches with `setsid()` leaves the signalled
+        process group and outlives this call. Delete the sandbox to be certain
+        everything it started is gone.
+        """
+        if self.id is None:
+            raise SandboxError(
+                "This process cannot be stopped individually: its sandbox runs a sandbox server "
+                "that predates opaque process ids, so the server never issued one. Recycle the "
+                "pool's hosts, or delete the sandbox to stop everything it started."
+            )
+        response = self._sandbox._request("DELETE", f"/processes/{self.id}")
+        return bool(response.json().get("killed", False))
+
+
+@dataclass
+class FileEntry:
+    """A file or directory inside a sandbox."""
+
+    name: str
+    path: str
+    type: Literal["file", "dir", "symlink"]
+    size: int
+    mtime_ms: int | None = None
+    mode: str = ""
+
+
+@contextmanager
+def _open_download_target(local_path: Path) -> Iterator[BinaryIO]:
+    """Yield a writer whose bytes only appear at `local_path` once the download completes.
+
+    Writing straight to the destination has three problems: an interrupted transfer leaves a
+    truncated file at the final name; `open(path, "wb")` follows a symlink sitting there, so
+    the sandbox's output can be redirected into any file this process can write; and a
+    predictable temp name is a race another local process can win.
+
+    So the bytes go to a temp file in the destination directory, created `O_EXCL` (nobody
+    else's file) and `O_NOFOLLOW` (not a symlink) with mode `0600` and an unguessable name,
+    then `os.replace`d into place. `rename` does not follow symlinks either, so a symlinked
+    destination is *replaced* rather than written through, and a failure leaves nothing behind.
+    """
+    tmp = local_path.parent / f".{local_path.name}.{token_hex(8)}.part"
+    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0) | getattr(os, "O_BINARY", 0)
+    fd = os.open(tmp, flags, 0o600)
+    try:
+        with os.fdopen(fd, "wb") as f:
+            yield f
+        os.replace(tmp, local_path)
+    except BaseException:
+        tmp.unlink(missing_ok=True)
+        raise
+
+
+class SandboxFiles:
+    """Filesystem operations inside a sandbox, available as [`Sandbox.files`].
+
+    In shared (pool) mode, paths are rooted at the sandbox's private home — the
+    only place its code can write — so a leading `/` is taken relative to that
+    home. In dedicated mode, paths are absolute on the container filesystem.
+
+    Paths are normalized lexically, then resolved by the host server relative to an open
+    home-directory descriptor. The file API refuses symlinks on every component, including
+    links whose targets are inside the same home.
+    """
+
+    # Above this size, transfers are split into ranged requests over parallel
+    # connections: a single TCP stream through the jobs proxy is limited by the
+    # bandwidth-delay product (~2 MiB/s at ~100ms RTT); parallel streams scale it.
+    PARALLEL_THRESHOLD = 2 * 1024 * 1024
+    PARALLEL_CHUNK_SIZE = 1 * 1024 * 1024
+    PARALLEL_MAX_WORKERS = 16
+    # Ceiling on what `read`/`read_text` will materialize in memory. A parallel
+    # read used to collect every chunk into a list and *then* join it, so a 2 GB
+    # file peaked at roughly twice its size before the caller saw a byte. Reading
+    # a file into memory is inherently bounded by the file; this makes the bound
+    # explicit and points at the streaming alternative instead of dying in an
+    # allocator.
+    MAX_READ_BYTES = 512 * 1024 * 1024
+
+    def __init__(self, sandbox: "Sandbox") -> None:
+        self._sandbox = sandbox
+
+    def read(self, path: str) -> bytes:
+        """Read a file from the sandbox and return its content as bytes.
+
+        Raises [`SandboxError`] above `MAX_READ_BYTES`; use [`download`] for
+        anything that large, which streams to disk instead of buffering.
+        """
+        size = self.stat(path).size
+        if size > self.MAX_READ_BYTES:
+            raise SandboxError(
+                f"{path} is {size} bytes, over the {self.MAX_READ_BYTES}-byte limit for reading into "
+                "memory. Use `files.download(path, local_path)`, which streams to disk."
+            )
+        if size > self.PARALLEL_THRESHOLD:
+            # Write each range into one preallocated buffer as it arrives, rather
+            # than collecting every chunk and joining: the join doubled peak memory.
+            buffer = bytearray(size)
+            for offset, part in self._read_ranges(path, size):
+                buffer[offset : offset + len(part)] = part
+            return bytes(buffer)
+        return self._read_range(path, 0, size)
+
+    def read_text(self, path: str, encoding: str = "utf-8") -> str:
+        """Read a file from the sandbox and return its content as a string."""
+        return self.read(path).decode(encoding)
+
+    def write(self, path: str, data: str | bytes | BinaryIO, mode: str | None = None) -> None:
+        """Write content to a file in the sandbox (parent directories are created)."""
+        if isinstance(data, str):
+            data = data.encode()
+        elif not isinstance(data, bytes):
+            data = data.read()  # binary file object
+        if len(data) > self.PARALLEL_THRESHOLD:
+            self._write_ranges(path, data, mode)
+            return
+        params = {"path": path}
+        if mode is not None:
+            params["mode"] = mode
+        self._sandbox._request("PUT", "/files/write", params=params, content=data)
+
+    def upload(self, local_path: str | Path, path: str, mode: str | None = None) -> None:
+        """Upload a local file to the sandbox.
+
+        The file is opened once and both sized (`fstat`) and read through that same
+        descriptor, so what is uploaded is the file that was measured -- rather than
+        whatever the path resolves to a moment later.
+        """
+        with open(local_path, "rb") as f:
+            size = os.fstat(f.fileno()).st_size
+            if size > self.PARALLEL_THRESHOLD:
+                # Each worker reads its own range straight off the descriptor, so
+                # a large upload no longer means holding the whole file in memory
+                # (`f.read()` on a 10 GB file was 10 GB of resident bytes).
+                self._write_ranges_from_file(path, f, size, mode)
+            else:
+                self.write(path, f, mode=mode)
+
+    def download(self, path: str, local_path: str | Path) -> None:
+        """Download a file from the sandbox.
+
+        The bytes land in a private temp file next to the destination and are renamed
+        over it at the end, so an interrupted download leaves no truncated file and a
+        symlink sitting at `local_path` is replaced rather than followed.
+        """
+        size = self.stat(path).size
+        with _open_download_target(Path(local_path)) as f:
+            if size > self.PARALLEL_THRESHOLD:
+                # Seek-and-write per range as it completes, so peak memory is a
+                # few chunks rather than the whole file.
+                for offset, part in self._read_ranges(path, size):
+                    f.seek(offset)
+                    f.write(part)
+                return
+            with self._sandbox._stream("GET", "/files/read", params={"path": path}) as response:
+                for chunk in response.iter_bytes(chunk_size=1024 * 1024):
+                    f.write(chunk)
+
+    def _ranges(self, size: int) -> List[tuple[int, int]]:
+        chunk = self.PARALLEL_CHUNK_SIZE
+        return [(offset, min(chunk, size - offset)) for offset in range(0, size, chunk)]
+
+    def _parallel(self, items: List[Any], fn: Callable[[Any], Any]) -> List[Any]:
+        """Run `fn(item)` over items concurrently.
+
+        All workers share the sandbox's `httpx2.Client`, which is thread-safe and pools
+        connections, so parallel transfers fan out over several streams at once.
+        """
+        workers = min(self.PARALLEL_MAX_WORKERS, len(items))
+        with ThreadPoolExecutor(workers) as executor:
+            return list(executor.map(fn, items))
+
+    def _read_range(self, path: str, offset: int, length: int) -> bytes:
+        data = bytearray()
+        with self._sandbox._stream(
+            "GET", "/files/read", params={"path": path, "offset": offset, "length": length}
+        ) as response:
+            for chunk in response.iter_bytes(chunk_size=1024 * 1024):
+                if len(data) + len(chunk) > length:
+                    raise SandboxError("File response exceeded the requested range.")
+                data.extend(chunk)
+        if len(data) != length:
+            raise SandboxError("File changed size during transfer; retry the download.")
+        return bytes(data)
+
+    def _read_ranges(self, path: str, size: int) -> Iterator[tuple[int, bytes]]:
+        """Fetch every range in parallel, yielding `(offset, bytes)` as they land.
+
+        Yielding rather than returning a list is the point: the caller places each
+        chunk and drops it, so peak memory is a few chunks instead of the whole
+        file plus a copy.
+        """
+
+        def fetch(rng: tuple[int, int]) -> tuple[int, bytes]:
+            offset, length = rng
+            return offset, self._read_range(path, offset, length)
+
+        ranges = self._ranges(size)
+        workers = min(self.PARALLEL_MAX_WORKERS, len(ranges))
+        with ThreadPoolExecutor(workers) as executor:
+            for start in range(0, len(ranges), workers):
+                yield from executor.map(fetch, ranges[start : start + workers])
+
+    def _write_ranges(self, path: str, data: bytes, mode: str | None) -> None:
+        def push(rng: tuple[int, int]) -> None:
+            offset, length = rng
+            self._put_range(path, offset, data[offset : offset + length], mode, total=len(data))
+
+        self._parallel(self._ranges(len(data)), push)
+
+    def _write_ranges_from_file(self, path: str, source: BinaryIO, size: int, mode: str | None) -> None:
+        """Upload `source` in parallel ranges, reading each range on demand.
+
+        Serialize reads from the shared descriptor; network writes still overlap.
+        """
+        read_lock = threading.Lock()
+
+        def push(rng: tuple[int, int]) -> None:
+            offset, length = rng
+            with read_lock:
+                source.seek(offset)
+                chunk = source.read(length)
+            if len(chunk) != length:
+                raise SandboxError("Upload source changed size during transfer.")
+            self._put_range(path, offset, chunk, mode, total=size)
+
+        self._parallel(self._ranges(size), push)
+
+    def _put_range(self, path: str, offset: int, chunk: bytes, mode: str | None, *, total: int) -> None:
+        params: dict[str, Any] = {"path": path, "offset": offset}
+        if mode is not None:
+            params["mode"] = mode
+        # Tell the server the intended final size. A ranged write does not
+        # truncate, so overwriting a larger file with a smaller one used to leave
+        # the old bytes past the new end.
+        if offset + len(chunk) >= total:
+            params["truncate_to"] = total
+        self._sandbox._request("PUT", "/files/write", params=params, content=chunk)
+
+    def list(self, path: str) -> List[FileEntry]:
+        """List a directory in the sandbox.
+
+        The server paginates, so this follows the cursor and returns everything --
+        a caller sees one list regardless of how the directory is chunked on the
+        wire.
+        """
+        entries: List[FileEntry] = []
+        after: str | None = None
+        while True:
+            params: dict[str, Any] = {"path": path}
+            if after is not None:
+                params["after"] = after
+            payload = self._sandbox._request("GET", "/files/list", params=params).json()
+            entries.extend(FileEntry(**entry) for entry in payload["entries"])
+            after = payload.get("next")
+            if not after:
+                return entries
+
+    def stat(self, path: str) -> FileEntry:
+        """Get metadata of a file or directory in the sandbox."""
+        response = self._sandbox._request("GET", "/files/stat", params={"path": path})
+        return FileEntry(**response.json())
+
+    def exists(self, path: str) -> bool:
+        """Check whether a path exists in the sandbox."""
+        try:
+            self.stat(path)
+            return True
+        except SandboxError as e:
+            if e.status_code == 404:
+                return False
+            raise  # network/auth/server errors must not be silently reported as "missing"
+
+    def delete(self, path: str, recursive: bool = False) -> None:
+        """Delete a file or directory in the sandbox."""
+        params = {"path": path}
+        if recursive:
+            params["recursive"] = "1"
+        self._sandbox._request("DELETE", "/files/delete", params=params)
+
+    def mkdir(self, path: str) -> None:
+        """Create a directory (and parents) in the sandbox."""
+        self._sandbox._request("POST", "/files/mkdir", params={"path": path})
+
+
+def _exec_payload(cmd: str | List[str], shell: bool | None) -> dict[str, Any]:
+    """Build the `cmd`/`shell` part of an `/exec` payload, validating their consistency."""
+    if shell is True and not isinstance(cmd, str):
+        raise ValueError("shell=True requires `cmd` to be a shell command string, not a list.")
+    if shell is False and isinstance(cmd, str):
+        raise ValueError("shell=False requires `cmd` to be an argv list (e.g. ['echo', 'hi']), not a string.")
+    payload: dict[str, Any] = {"cmd": cmd}
+    if shell is not None:
+        payload["shell"] = shell
+    return payload
+
+
+def _iter_events(response: httpx2.Response) -> Iterator[dict]:
+    """Iterate NDJSON events from a streaming response, skipping keepalive pings."""
+    for line in response.iter_lines():
+        if not line:
+            continue
+        event = json.loads(line)
+        if event.get("event") != "ping":
+            yield event
+
+
+def _raise_for_status(response: httpx2.Response) -> None:
+    """Read the error body and raise a SandboxError (works for streaming responses too)."""
+    response.read()  # no-op for buffered responses, reads the body for streaming ones
+    try:
+        message = response.json()["error"]
+    except Exception:
+        message = response.text[:500]
+    raise SandboxError(f"Sandbox API error ({response.status_code}): {message}", status_code=response.status_code)
+
+
+def _check_server_protocol(response: httpx2.Response, job_id: str) -> None:
+    """Refuse a server whose wire contract this client cannot drive.
+
+    Permissive in one direction only. A *newer* server is accepted: it declares its own
+    backwards compatibility by keeping the protocol integer it still supports. An *older* one
+    is refused, because the mismatches are things like the per-sandbox capability token, which
+    surfaces as a 403 on an unrelated route several calls later instead of here.
+
+    `version` is no use for this: it moves for a doc fix as readily as for a protocol break.
+    """
+    try:
+        protocol = response.json().get("protocol")
+    except Exception:
+        protocol = None
+    if isinstance(protocol, int) and not isinstance(protocol, bool) and protocol >= SANDBOX_SERVER_PROTOCOL:
+        return
+    # No field at all means a server published before protocols were declared, i.e. 1.
+    reported = protocol if protocol is not None else "1 (declares no protocol)"
+    raise SandboxError(
+        f"Sandbox job {job_id} runs sbx-server protocol {reported}, but this version of "
+        f"huggingface_hub needs protocol {SANDBOX_SERVER_PROTOCOL} or newer. A pool host keeps the "
+        "server binary it downloaded at boot for up to 24h, so recycle this pool's hosts (kill them, "
+        "or let them idle-time-out) to pick up the current server."
+    )
+
+
+class _SandboxAuth(httpx2.Auth):
+    """Attach the *current* HF bearer to every request.
+
+    The bearer used to be captured once when the transport was built. A sandbox
+    host lives up to 24h, so an OIDC/OAuth credential can expire or rotate inside
+    that window, after which every request to the Jobs proxy failed even though
+    the handle was still perfectly good. Reading it per request fixes that.
+
+    The `X-Sandbox-Token` is deliberately *not* re-derived: the server holds the
+    value derived from the bearer that created the job, so re-deriving from a
+    rotated bearer would produce a token the server has never seen. The two
+    credentials answer different gates -- the proxy wants a live bearer, the
+    server wants the original capability -- and only the first needs refreshing.
+    """
+
+    def __init__(self, api: HfApi) -> None:
+        self._api = api
+
+    def auth_flow(self, request):
+        request.headers["Authorization"] = f"Bearer {_effective_token(self._api)}"
+        yield request
+
+
+def _require_scoped_token(token: Any) -> str:
+    if not isinstance(token, str) or not token:
+        raise SandboxError(
+            "The pool host returned no valid sandbox-scoped token; recycle it with an updated sbx-server."
+        )
+    return token
+
+
+class _SandboxServer:
+    """HTTP transport to one `sbx-server` instance — a dedicated job or a shared host.
+
+    Owns the `httpx2.Client`, the base URL and the auth headers.
+    In dedicated mode a server is paired 1:1 with its [`Sandbox`
+    In pool mode one server (one host job) is shared by many sandboxes, and `live`/`capacity` track packing.
+    """
+
+    def __init__(
+        self,
+        *,
+        job_id: str,
+        owner: str,
+        image: str | None,
+        base_url: str,
+        nonce: str,
+        sandbox_token: str,
+        api: HfApi,
+        max_connections: int = 10,
+        capacity: int = 0,
+    ) -> None:
+        self.job_id = job_id
+        self.owner = owner
+        self._image = image
+        self.base_url = base_url
+        # Public nonce the sandbox token is derived from; kept so a host can be persisted
+        # to (and rebuilt from) the pool cache without re-reading the job labels.
+        self.nonce = nonce
+        self._api = api
+        self._sandbox_token = sandbox_token
+        # Packing bookkeeping (shared mode only).
+        self.capacity = capacity
+        self.live = 0
+        # False only for hosts rebuilt from the (best-effort) pool cache: their job may
+        # be gone, so the first failed request drops them instead of failing the create.
+        self.verified = True
+        # Whether *this* process started this host job, and may therefore cancel
+        # it. Ownership belongs to the host, not to the pool handle: a handle used
+        # to cancel hosts it had merely discovered via labels, which may have been
+        # started by another process -- or another member of the namespace -- and
+        # may be serving their sandboxes.
+        self.owned = False
+        # httpx2.Client is thread-safe, so a single client serves both sequential requests
+        # and the concurrent workers used for parallel file transfers / many sandboxes.
+        self._client = httpx2.Client(
+            headers={"X-Sandbox-Token": sandbox_token},
+            auth=_SandboxAuth(api),
+            limits=httpx2.Limits(max_connections=max_connections, max_keepalive_connections=max_connections),
+            # Every request on this client carries the HF bearer and a sandbox token, and there
+            # is no redirect in this protocol -- the Jobs proxy serves the in-job server
+            # directly. Following one would hand both credentials to a destination that the
+            # response, rather than the client, chose.
+            follow_redirects=False,
+        )
+
+    @classmethod
+    def from_job(
+        cls,
+        *,
+        job: JobInfo,
+        nonce: str,
+        sandbox_token: str,
+        api: HfApi,
+        max_connections: int = 10,
+        capacity: int = 0,
+    ) -> "_SandboxServer":
+        """Build a server from a freshly fetched job (reads its exposed server URL)."""
+        return cls(
+            job_id=job.id,
+            owner=job.owner.name,
+            image=job.docker_image or job.space_id,
+            base_url=_find_server_url(job),
+            nonce=nonce,
+            sandbox_token=sandbox_token,
+            api=api,
+            max_connections=max_connections,
+            capacity=capacity,
+        )
+
+    @property
+    def image(self) -> str | None:
+        return self._image
+
+    def _with_token(self, kwargs: dict, sandbox_token: str | None) -> dict:
+        """Override `X-Sandbox-Token` for one request.
+
+        The client-level header carries the *host* credential, which manages the
+        pool. A pooled sandbox's own operations should present that sandbox's
+        capability token instead, so nothing wider than the sandbox is offered on
+        a per-sandbox call.
+        """
+        if sandbox_token is not None:
+            kwargs["headers"] = {**kwargs.get("headers", {}), "X-Sandbox-Token": sandbox_token}
+        return kwargs
+
+    def request(self, method: str, path: str, *, sandbox_token: str | None = None, **kwargs) -> httpx2.Response:
+        """Request to the in-job server. Raises SandboxError on API errors."""
+        timeout = kwargs.pop("timeout", httpx2.Timeout(60.0, connect=10.0))
+        kwargs = self._with_token(kwargs, sandbox_token)
+        response = self._client.request(method, self.base_url + path, timeout=timeout, **kwargs)
+        if response.status_code >= 400:
+            _raise_for_status(response)
+        return response
+
+    @contextmanager
+    def stream(
+        self, method: str, path: str, *, sandbox_token: str | None = None, **kwargs
+    ) -> Iterator[httpx2.Response]:
+        """Streaming request to the in-job server. Raises SandboxError on API errors."""
+        timeout = kwargs.pop("timeout", httpx2.Timeout(70.0, connect=10.0))  # server pings every 15s
+        kwargs = self._with_token(kwargs, sandbox_token)
+        with self._client.stream(method, self.base_url + path, timeout=timeout, **kwargs) as response:
+            if response.status_code >= 400:
+                _raise_for_status(response)
+            yield response
+
+    def sandbox_token(self, local_id: str) -> str:
+        """Recover a pooled sandbox's capability using the host management credential."""
+        data = self.request("GET", f"/v1/sandboxes/{local_id}/token").json()
+        return _require_scoped_token(data.get("token"))
+
+    def close(self) -> None:
+        self._client.close()
+
+    def cancel_job(self) -> None:
+        self._api.cancel_job(job_id=self.job_id, namespace=self.owner)
+
+    def wait_ready(self, start_timeout: float) -> None:
+        """Poll /health until the server answers; fail fast (with logs) if the job dies."""
+        deadline = time.time() + start_timeout
+        last_job_check = 0.0
+        while time.time() < deadline:
+            try:
+                response = self._client.get(self.base_url + "/health", timeout=httpx2.Timeout(5.0))
+                if response.status_code == 200:
+                    _check_server_protocol(response, self.job_id)
+                    return
+            except httpx2.RequestError:
+                pass
+            if time.time() - last_job_check > 2.0:
+                last_job_check = time.time()
+                job = self._api.inspect_job(job_id=self.job_id, namespace=self.owner)
+                if job.status.stage in _TERMINAL_STAGES:
+                    logs = _tail_job_logs(self._api, self.job_id, namespace=self.owner)
+                    raise SandboxError(
+                        f"Sandbox job {self.job_id} terminated during startup "
+                        f"(status: {job.status.stage}, message: {job.status.message}).{logs}"
+                    )
+            time.sleep(0.15)
+        raise SandboxError(f"Sandbox job {self.job_id} did not become ready within {start_timeout:.0f}s.")
+
+
+class _KillMethod:
+    """Lets `kill` work both as a classmethod and an instance method."""
+
+    @overload
+    def __get__(self, instance: None, owner: type) -> Callable[..., None]: ...
+    @overload
+    def __get__(self, instance: "Sandbox", owner: type) -> Callable[[], None]: ...
+    def __get__(self, instance: "Sandbox | None", owner: type) -> Callable[..., None]:
+        if instance is not None:
+            return instance._kill
+
+        def kill(sandbox_id: str, *, namespace: str | None = None, token: str | None = None) -> None:
+            owner.connect(sandbox_id, namespace=namespace, token=token).kill()  # type: ignore[attr-defined]
+
+        return kill
+
+
+class Sandbox:
+    """An isolated cloud machine running on Hugging Face Jobs.
+
+    > [!NOTE]
+    > The Sandbox API is experimental. Its API and behavior may change without notice.
+
+    Create a dedicated one with [`Sandbox.create`] (one job per sandbox), or get many cheap shared ones from a [`SandboxPool`].
+    Reattach to a running sandbox from anywhere with [`Sandbox.connect`]. Use as a context manager to terminate it on exit:
+
+    ```python
+    >>> from huggingface_hub import Sandbox
+    >>> with Sandbox.create(image="python:3.12") as sbx:
+    ...     print(sbx.run("python --version").stdout)
+    ```
+    """
+
+    def __init__(
+        self,
+        *,
+        id: str,
+        server: _SandboxServer,
+        local_id: str | None,
+        owns_sandbox: bool,
+        owns_server: bool,
+        sandbox_token: str | None = None,
+    ) -> None:
+        self.id = id
+        self._server = server
+        # Capability token for this sandbox alone (pool mode). Sent instead of the
+        # host credential on every per-sandbox call, so a pooled sandbox's
+        # operations -- and the headers handed to a port-proxy client -- confer no
+        # authority over its siblings or over the pool. A dedicated job is already
+        # one sandbox, so its job credential is the appropriate token.
+        self._sandbox_token = server._sandbox_token if local_id is None else _require_scoped_token(sandbox_token)
+        # None in dedicated mode; the host-local sandbox id in shared mode.
+        self._local_id = local_id
+        # Path prefix for all in-server operations: dedicated routes live under
+        # /v1/*, shared ones under /v1/sandboxes/<local_id>/*.
+        self._base_path = "/v1" if local_id is None else f"/v1/sandboxes/{local_id}"
+        # Whether exiting a `with` block terminates the sandbox (True for sandboxes
+        # we created, False for ones reattached via connect()).
+        self._owns_sandbox = owns_sandbox
+        # Whether closing/killing this sandbox also closes the HTTP client. False
+        # for pool sandboxes, whose client (the host) is owned by the pool.
+        self._owns_server = owns_server
+        # Set by SandboxPool to free a packing slot when a shared sandbox is killed.
+        self._on_kill: Callable[["Sandbox"], None] | None = None
+        self._killed = False
+        self.files = SandboxFiles(self)
+
+    # ------------------------------------------------------------------ lifecycle
+
+    @classmethod
+    def create(
+        cls,
+        image: str = DEFAULT_IMAGE,
+        *,
+        flavor: str = "cpu-basic",
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        env: dict[str, Any] | None = None,
+        secrets: dict[str, Any] | None = None,
+        volumes: List[Volume] | None = None,
+        namespace: str | None = None,
+        forward_hf_token: bool = False,
+        labels: dict[str, str] | None = None,
+        start_timeout: float = 120.0,
+        token: str | None = None,
+    ) -> "Sandbox":
+        """Create a dedicated sandbox (one HF Job) and block until it is ready (~7s on cpu-basic).
+
+        Each sandbox is a full isolated VM, so this is the right choice for GPU
+        workloads or untrusted code. To fan out many cheap CPU sandboxes instead, use
+        [`SandboxPool`].
+
+        The job runs with a fixed 24h maximum lifetime; `idle_timeout` is the real
+        keeper — an idle sandbox shuts itself down well before that.
+
+        Args:
+            image (`str`, *optional*, defaults to `"python:3.12"`):
+                Any Docker image with `/bin/sh` (Docker Hub or `hf.co/spaces/...`).
+            flavor (`str`, *optional*, defaults to `"cpu-basic"`):
+                Hardware flavor, e.g. `"cpu-basic"`, `"a10g-small"`. See `hf jobs hardware`.
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Auto-shutdown after this much inactivity (no API calls, no running
+                processes). Defaults to 10 minutes; pass `None` to disable. Note that a
+                *foreground* command is not currently counted as activity, so a single
+                `run()` that takes longer than this without other API traffic can have its
+                sandbox shut down under it — raise the timeout (or pass `None`) for long
+                single commands.
+            env (`dict[str, Any]`, *optional*):
+                Environment variables available in the sandbox.
+            secrets (`dict[str, Any]`, *optional*):
+                Secret environment variables (encrypted server-side).
+            volumes (`List[Volume]`, *optional*):
+                HF repos/buckets to mount, see [`Volume`].
+            namespace (`str`, *optional*):
+                User or org namespace to run under (defaults to current user).
+            forward_hf_token (`bool`, *optional*, defaults to `False`):
+                If True, your HF token is injected as `HF_TOKEN` (opt-in).
+            labels (`dict[str, str]`, *optional*):
+                Labels to attach to the underlying HF Job.
+            start_timeout (`float`, *optional*, defaults to `120.0`):
+                Max seconds to wait for the sandbox to become ready.
+            token (`str`, *optional*):
+                HF token override.
+
+        The image only needs `/bin/sh`. The sandbox server is downloaded at startup with
+        `wget`/`curl` if available, otherwise read off an always-mounted server bucket (which
+        adds ~2-3s to cold start, so shipping `wget`/`curl` keeps it fast).
+        """
+        if labels is not None:
+            if not isinstance(labels, dict):
+                raise ValueError(f"`labels` must be a dict[str, str], got {type(labels).__name__}")
+            for key, value in labels.items():
+                if not isinstance(key, str) or not isinstance(value, str):
+                    raise ValueError("`labels` keys and values must be strings")
+                if key in RESERVED_SANDBOX_LABELS:
+                    raise ValueError(f"Label '{key}' is reserved by huggingface_hub Sandbox and cannot be overridden.")
+
+        api = HfApi(token=token)
+        hf_token = _effective_token(api)
+        nonce = token_hex(16)
+        sandbox_token = _derive_sandbox_token(hf_token, nonce)
+
+        command, job_env, job_secrets, job_volumes = _bootstrap_job_spec(
+            api,
+            hf_token,
+            env=env,
+            secrets=secrets,
+            volumes=volumes,
+            idle_timeout=idle_timeout,
+            forward_hf_token=forward_hf_token,
+            sandbox_token=sandbox_token,
+        )
+
+        job = api.run_job(
+            image=image,
+            command=command,
+            env=job_env,
+            secrets=job_secrets,
+            flavor=flavor,
+            timeout=SANDBOX_MAX_LIFETIME,
+            labels={**(labels or {}), SANDBOX_LABEL: "1", MODE_LABEL: MODE_DEDICATED, NONCE_LABEL: nonce},
+            volumes=job_volumes or None,
+            expose=[SANDBOX_SERVER_PORT],
+            namespace=namespace,
+        )
+        server: "_SandboxServer | None" = None
+        try:
+            server = _SandboxServer.from_job(
+                job=job,
+                nonce=nonce,
+                sandbox_token=sandbox_token,
+                api=api,
+                max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+            )
+            server.wait_ready(start_timeout)
+        except Exception:
+            # run_job already started a billable job; cancel it before re-raising so it
+            # doesn't linger as an orphan (e.g. if the server port isn't exposed or startup fails).
+            try:
+                api.cancel_job(job_id=job.id, namespace=job.owner.name)
+            except Exception as e:
+                logger.warning(f"Failed to cancel sandbox job {job.id} after startup failure: {e}")
+            if server is not None:
+                server.close()
+            raise
+        return cls(id=job.id, server=server, local_id=None, owns_sandbox=True, owns_server=True)
+
+    @classmethod
+    def connect(cls, sandbox_id: str, *, namespace: str | None = None, token: str | None = None) -> "Sandbox":
+        """Reattach to a running sandbox from anywhere, using only its id."""
+        api = HfApi(token=token)
+        sandbox_id, namespace = _split_sandbox_id(sandbox_id, namespace)
+        if SHARED_ID_SEP in sandbox_id:
+            host_job_id, local_id = sandbox_id.split(SHARED_ID_SEP, 1)
+            server = _connect_host(api, host_job_id, namespace=namespace)
+            try:
+                existing = {item["id"] for item in server.request("GET", "/v1/sandboxes").json()}
+                if local_id not in existing:
+                    raise SandboxError(f"Sandbox {sandbox_id} no longer exists on host {host_job_id}.")
+                # Recover the sandbox's capability token with the host credential, so
+                # this handle operates with the narrow one from here on.
+                sandbox_token = server.sandbox_token(local_id)
+            except Exception:
+                server.close()  # don't leak the HTTP client when the host is gone/unreachable
+                raise
+            return cls(
+                id=sandbox_id,
+                server=server,
+                local_id=local_id,
+                owns_sandbox=False,
+                owns_server=True,
+                sandbox_token=sandbox_token,
+            )
+
+        job = api.inspect_job(job_id=sandbox_id, namespace=namespace)
+        labels = job.labels or {}
+        nonce = labels.get(NONCE_LABEL)
+        if labels.get(SANDBOX_LABEL) != "1" or nonce is None:
+            raise SandboxError(f"Job {sandbox_id} is not a sandbox (missing '{SANDBOX_LABEL}' label).")
+        if labels.get(MODE_LABEL) == MODE_POOL:
+            raise SandboxError(
+                f"Job {sandbox_id} is a sandbox host, not a single sandbox. Connect to one of its "
+                f"sandboxes with id '<host_job_id>{SHARED_ID_SEP}<local_id>'."
+            )
+        if job.status.stage != "RUNNING":
+            raise SandboxError(f"Sandbox {sandbox_id} is not running (status: {job.status.stage}).")
+        sandbox_token = _derive_sandbox_token(_effective_token(api), nonce)
+        server = _SandboxServer.from_job(
+            job=job,
+            nonce=nonce,
+            sandbox_token=sandbox_token,
+            api=api,
+            max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+        )
+        return cls(id=job.id, server=server, local_id=None, owns_sandbox=False, owns_server=True)
+
+    # `kill` is both a classmethod (`Sandbox.kill(id)`) and an instance method (`sbx.kill()`),
+    # dispatched by the `_KillMethod` descriptor; `_kill` holds the instance behaviour.
+    kill = _KillMethod()
+
+    def _kill(self) -> None:
+        """Terminate the sandbox. Idempotent.
+
+        Dedicated sandboxes cancel their underlying job; shared sandboxes are
+        removed from their host (freeing a slot) while the host keeps running.
+        """
+        if self._killed:
+            return
+        try:
+            if self._local_id is None:
+                self._server.cancel_job()
+            else:
+                self._server.request("DELETE", f"/v1/sandboxes/{self._local_id}", sandbox_token=self._sandbox_token)
+        except Exception as e:
+            # Don't mark as killed: a later kill() call should retry so nothing leaks.
+            logger.warning(f"Failed to kill sandbox {self.id}: {e}")
+            return
+        self._killed = True
+        if self._on_kill is not None:
+            self._on_kill(self)
+        if self._owns_server:
+            self._server.close()
+
+    def close(self) -> None:
+        """Release the local HTTP client without terminating the sandbox. Idempotent.
+
+        No-op for pool sandboxes (the client belongs to the pool's host).
+        """
+        if self._owns_server:
+            self._server.close()
+
+    def __enter__(self) -> "Sandbox":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        if self._owns_sandbox:
+            self.kill()
+        else:
+            self.close()
+
+    # ------------------------------------------------------------------ exec
+
+    @overload
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = ...,
+        env: dict[str, Any] | None = ...,
+        cwd: str | None = ...,
+        timeout: float | None = ...,
+        stdin: str | None = ...,
+        on_stdout: Callable[[str], None] | None = ...,
+        on_stderr: Callable[[str], None] | None = ...,
+        check: bool = ...,
+        capture_output: bool = ...,
+        background: Literal[False] = ...,
+    ) -> SandboxCommandResult: ...
+
+    @overload
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = ...,
+        env: dict[str, Any] | None = ...,
+        cwd: str | None = ...,
+        background: Literal[True],
+    ) -> SandboxProcess: ...
+
+    def run(
+        self,
+        cmd: str | List[str],
+        *,
+        shell: bool | None = None,
+        env: dict[str, Any] | None = None,
+        cwd: str | None = None,
+        timeout: float | None = None,
+        stdin: str | None = None,
+        on_stdout: Callable[[str], None] | None = None,
+        on_stderr: Callable[[str], None] | None = None,
+        check: bool = True,
+        capture_output: bool = True,
+        background: bool = False,
+    ) -> SandboxCommandResult | SandboxProcess:
+        """Run a command in the sandbox and wait for it, streaming output live.
+
+        With `background=True` the command is started detached and `run` returns a
+        [`SandboxProcess`] immediately, without waiting for it to finish — handy for
+        servers and other long-running processes. List them later with [`Sandbox.processes`]
+        and stop one with [`SandboxProcess.kill`]. The streaming/wait-only options
+        (`timeout`, `stdin`, `on_stdout`, `on_stderr`, `check`) don't apply in that mode.
+
+        Args:
+            cmd (`str` or `List[str]`):
+                A shell command string (run with `/bin/sh -c`) or an argv list (exec'd directly).
+            shell (`bool`, *optional*):
+                Force the execution mode instead of inferring it from the type of `cmd`.
+                `True` runs through `/bin/sh -c` and requires `cmd` to be a string; `False`
+                exec's `cmd` directly and requires it to be an argv list. `None` (default)
+                infers from the type. Set it explicitly to avoid the type-driven footgun (e.g.
+                `["echo hi"]` being exec'd as a single program named `"echo hi"`).
+            env (`dict[str, Any]`, *optional*):
+                Extra environment variables for this command.
+            cwd (`str`, *optional*):
+                Working directory.
+            timeout (`float`, *optional*):
+                Kill the command (whole process group) after this many seconds.
+            stdin (`str`, *optional*):
+                Data to write to the command's stdin.
+            on_stdout (`Callable[[str], None]`, *optional*):
+                Callback invoked with stdout chunks as they arrive.
+            on_stderr (`Callable[[str], None]`, *optional*):
+                Callback invoked with stderr chunks as they arrive.
+            check (`bool`, *optional*, defaults to `True`):
+                If True, raise [`SandboxCommandError`] on non-zero exit.
+            capture_output (`bool`, *optional*, defaults to `True`):
+                If True, accumulate stdout/stderr into the returned result. Pass `False`
+                when you only want `on_stdout`/`on_stderr`: output is then handed to the
+                callbacks and dropped, so a command producing gigabytes does not have to fit
+                in memory. `result.stdout`/`result.stderr` are empty in that case.
+            background (`bool`, *optional*, defaults to `False`):
+                If True, start the command detached and return a [`SandboxProcess`] right
+                away instead of waiting for it and returning a [`SandboxCommandResult`].
+
+        Returns: a [`SandboxCommandResult`] (with `exit_code`, `stdout`, `stderr`,
+        `duration_ms`), or a [`SandboxProcess`] when `background=True`.
+        """
+        payload = _exec_payload(cmd, shell)
+        if env:
+            payload["env"] = env
+        if cwd:
+            payload["cwd"] = cwd
+        if background:
+            data = self._request("POST", "/processes", json=payload).json()
+            return SandboxProcess(
+                # Absent on a server that predates opaque ids; `kill()` then says so
+                # rather than sending a pid the server will reject.
+                id=data.get("id"),
+                pid=data["pid"],
+                cmd=cmd,
+                tag=data.get("tag"),
+                _sandbox=self,
+            )
+        if timeout is not None:
+            payload["timeout"] = timeout
+        if stdin is not None:
+            payload["stdin"] = stdin
+
+        # Output was accumulated unconditionally, even when a callback was
+        # consuming it -- so a streaming consumer still paid full memory for the
+        # command's entire output. `capture_output=False` opts out.
+        stdout_parts: list[str] = []
+        stderr_parts: list[str] = []
+        captured = 0
+        result: SandboxCommandResult | None = None
+
+        def keep(parts: list[str], data: str) -> None:
+            nonlocal captured
+            if not capture_output:
+                return
+            if captured + len(data) > MAX_CAPTURED_OUTPUT_CHARS:
+                raise SandboxError(
+                    f"command produced more than {MAX_CAPTURED_OUTPUT_CHARS} characters of output. "
+                    "Pass `capture_output=False` with `on_stdout`/`on_stderr` to stream it instead, "
+                    "or redirect it to a file in the sandbox and download that."
+                )
+            captured += len(data)
+            parts.append(data)
+
+        with self._stream("POST", "/exec", json=payload) as response:
+            for event in _iter_events(response):
+                if event["event"] == "stdout":
+                    keep(stdout_parts, event["data"])
+                    if on_stdout is not None:
+                        on_stdout(event["data"])
+                elif event["event"] == "stderr":
+                    keep(stderr_parts, event["data"])
+                    if on_stderr is not None:
+                        on_stderr(event["data"])
+                elif event["event"] == "exit":
+                    result = SandboxCommandResult(
+                        exit_code=event["exit_code"],
+                        stdout="".join(stdout_parts),
+                        stderr="".join(stderr_parts),
+                        signal=event.get("signal"),
+                        timed_out=event.get("timed_out", False),
+                        duration_ms=event.get("duration_ms", 0),
+                    )
+                    # Exit is terminal: a truncated HTTP tail must not mask the command result.
+                    break
+        if result is None:
+            raise SandboxError("connection lost while running command")
+        if check and (result.exit_code != 0 or result.timed_out):
+            raise SandboxCommandError(cmd=cmd, result=result)
+        return result
+
+    def processes(self) -> List[SandboxProcess]:
+        """List the background processes of this sandbox.
+
+        Returns the processes started with [`Sandbox.run`]`(..., background=True)`; stop one
+        with [`SandboxProcess.kill`]. Recently completed processes stay listed (with
+        `running=False` and their `exit_code`); the server keeps a bounded number of them, so a
+        sandbox that has run thousands of short commands will not list them all.
+        """
+        data = self._request("GET", "/processes").json()
+        return [
+            SandboxProcess(
+                id=p.get("id"),
+                pid=p["pid"],
+                cmd=p["cmd"],
+                tag=p.get("tag"),
+                started_at_ms=p.get("started_at_ms"),
+                running=p["running"],
+                exit_code=p.get("exit_code"),
+                _sandbox=self,
+            )
+            for p in data
+        ]
+
+    # ------------------------------------------------------------------ misc
+
+    @property
+    def image(self) -> str | None:
+        return self._server.image
+
+    @property
+    def host_id(self) -> str | None:
+        """For a shared/pool sandbox, the job id of the host running it (else None)."""
+        return self._server.job_id if self._local_id is not None else None
+
+    # ------------------------------------------------------------------ port proxy
+
+    def proxy_url_for(self, port: int | str, path: str = "/", *, scheme: str = "https://") -> str:
+        """Public URL that proxies through to a server running *inside* this sandbox.
+
+        Requests to the returned URL are forwarded by the in-job sandbox server to a
+        server you started in the sandbox on `port`, including WebSocket (`ws(s)://`)
+        upgrades and streamed responses. Pair it with [`proxy_headers`] for auth.
+
+        How the sandbox must listen on `port`:
+
+        - **Pool / shared sandbox**: it cannot bind a TCP port (Landlock), so bind a
+          **unix socket** at `$SBX_PROXY_DIR/<port>.sock` (the `SBX_PROXY_DIR` env var
+          is set in every sandbox). E.g. `uvicorn app:app --uds $SBX_PROXY_DIR/8000.sock`.
+        - **Dedicated sandbox**: bind a normal TCP port on `127.0.0.1:<port>`. (You can
+          also expose the port directly via the job proxy without going through here.)
+
+        Args:
+            port (`int` or `str`):
+                The port (pool: the `<port>` of the unix socket) the inner server listens on.
+            path (`str`, *optional*, defaults to `"/"`):
+                Path on the inner server to point at, e.g. `"/ws"`.
+            scheme (`str`, *optional*, defaults to `"https://"`):
+                URL scheme to build the link with. Defaults to `"https://"`; pass
+                `"wss://"` for a WebSocket client (the proxy is protocol-agnostic, so only
+                the client-side scheme changes).
+
+        Returns:
+            `str`: a URL like `https://<job_id>--49983.hf.jobs/v1/.../proxy/8000/ws` (or
+            `wss://...` with `scheme="wss://"`).
+
+        Example:
+            ```python
+            >>> url = sandbox.proxy_url_for(8000, "/ws", scheme="wss://")
+            >>> import websockets
+            >>> async with websockets.connect(url, additional_headers=sandbox.proxy_headers) as ws:
+            ...     await ws.send("hello")
+            ```
+        """
+        # base_url is always https://...; swap in the requested scheme (e.g. wss://) for the client.
+        host_and_rest = self._server.base_url.split("://", 1)[-1]
+        path = path if path.startswith("/") else "/" + path
+        return f"{scheme}{host_and_rest}{self._base_path}/proxy/{port}{path}"
+
+    @property
+    def proxy_headers(self) -> dict[str, str]:
+        """Auth headers to send with [`proxy_url_for`] requests (HF token + sandbox token).
+
+        Read these at the moment you use them: the HF token is resolved on access,
+        so a long-lived handle hands out a current bearer rather than one captured
+        when the sandbox was created.
+
+        For a pooled sandbox this is the sandbox's own capability token, not the
+        pool host's: these headers typically end up in a browser or WebSocket
+        client, so they should confer access to this sandbox and nothing else.
+        """
+        return {
+            "Authorization": f"Bearer {_effective_token(self._server._api)}",
+            "X-Sandbox-Token": self._sandbox_token,
+        }
+
+    def __repr__(self) -> str:
+        return f"Sandbox(id={self.id!r}, image={self.image!r})"
+
+    # ------------------------------------------------------------------ internals
+
+    def _request(self, method: str, resource: str, **kwargs) -> httpx2.Response:
+        return self._server.request(method, self._base_path + resource, sandbox_token=self._sandbox_token, **kwargs)
+
+    @contextmanager
+    def _stream(self, method: str, resource: str, **kwargs) -> Iterator[httpx2.Response]:
+        with self._server.stream(
+            method, self._base_path + resource, sandbox_token=self._sandbox_token, **kwargs
+        ) as response:
+            yield response
+
+
+class SandboxPool:
+    """A fleet of shared "host" jobs, each packing many landlock-isolated sandboxes.
+
+    > [!WARNING]
+    > The Sandbox API is experimental. Its API and behavior may change without notice.
+    >
+    > **Pooled sandboxes are for workloads inside one trust boundary.** A pooled sandbox is a uid plus a Landlock
+    > ruleset inside a shared VM — not a VM of its own — and every sandbox on a host shares that host's auth token
+    > and its privileged control plane. Use a pool to fan out *your own* code cheaply. For mutually distrusting
+    > workloads, use [`Sandbox.create`], which gives each one its own VM. The specific gaps are listed under
+    > "Known limitations" in the sandbox conceptual guide.
+
+    One host is one billed HF Job (a VM); it runs the sandbox server and multiplexes
+    up to `sandboxes_per_host` lightweight sandboxes, isolated from each other by
+    uid + the Landlock LSM. This makes large fan-outs cheap (the VM cost is shared
+    across all its sandboxes) and fast (creating a sandbox is ~one proxy round-trip
+    once a host is warm). Best for many parallel CPU sandboxes such as RL rollouts;
+    for GPU or strong VM-level isolation between mutually-distrusting workloads, use
+    [`Sandbox.create`] instead.
+
+    The constructor pre-provisions `warm_up` hosts (default 1) and blocks until they are
+    ready; further hosts are then provisioned on demand as sandboxes are requested, and all
+    are torn down on `close()` (or when idle, via `idle_timeout`). The user never manages jobs:
+
+    ```python
+    >>> from huggingface_hub import SandboxPool
+    >>> with SandboxPool(image="python:3.12", flavor="cpu-basic", warm_up=2) as pool:
+    ...     boxes = [pool.create() for _ in range(100)]   # packed across the warm hosts
+    ...     print(boxes[0].run("echo hi").stdout)
+    hi
+    ```
+
+    `create()` makes **one** sandbox at a time: it reuses a host that still has free
+    capacity before booting a new one, so you grow on demand as work arrives. To avoid
+    a cold start on the first few calls, pre-provision hosts with `warm_up` (or
+    [`warm`]). Warm hosts are discovered via job labels, so reuse works **across
+    processes** too (a fresh pool with the same `image`/`flavor`/`name` attaches to
+    hosts an earlier run left behind):
+
+    ```python
+    >>> pool = SandboxPool(image="python:3.12")
+    >>> sbx = pool.create()    # finds a warm host (here or in another process), else boots one
+    ```
+    """
+
+    def __init__(
+        self,
+        image: str = DEFAULT_IMAGE,
+        *,
+        flavor: str = "cpu-basic",
+        sandboxes_per_host: int = DEFAULT_SANDBOXES_PER_HOST,
+        warm_up: int = 1,
+        max_hosts: int | None = None,
+        name: str | None = None,
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        namespace: str | None = None,
+        start_timeout: float = 120.0,
+        adopt_hosts: str = ADOPT_OWN,
+        token: str | None = None,
+        _connect_mode: bool = False,
+    ) -> None:
+        """Configure a pool and pre-provision `warm_up` hosts (blocks until they are ready).
+
+        Env/secrets are *not* set here: they belong to each sandbox and are passed to
+        `create(env=...)`, so sandboxes in the same pool can have different environments.
+
+        Args:
+            image (`str`, *optional*, defaults to `"python:3.12"`):
+                Docker image for the hosts (needs `/bin/sh`). All sandboxes in the
+                pool share this image.
+            flavor (`str`, *optional*, defaults to `"cpu-basic"`):
+                Hardware flavor for the host jobs (e.g. `"cpu-basic"`).
+            sandboxes_per_host (`int`, *optional*, defaults to `50`):
+                How many sandboxes to pack per host (per VM density).
+            warm_up (`int`, *optional*, defaults to `1`):
+                How many hosts to pre-provision in the constructor (which blocks
+                until they are ready), so an initial burst of `create()` calls doesn't pay
+                a host cold start each. Existing warm hosts (from the cache / other processes)
+                count towards it, so only the shortfall is booted; capped by `max_hosts`.
+                Defaults to 1 (a single host).
+            max_hosts (`int`, *optional*):
+                Optional cap on the number of host jobs (a cost ceiling). When
+                reached and all hosts are full, `create()` raises. The cap is enforced
+                per-process against the hosts this handle knows about, so two processes
+                using the same pool concurrently can exceed it. (Per-host density,
+                `sandboxes_per_host`, *is* enforced by the host itself.)
+            name (`str`, *optional*):
+                Pool name, used as the `hf-sandbox-pool` job label so the pool is
+                discoverable (e.g. `hf sandbox pool ls`, `connect()`). `create()` reuses
+                running hosts carrying this label (including from other processes) before
+                booting new ones, so distinct names keep separate pools from sharing hosts.
+                A random name is generated when omitted.
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Host idle timeout — a host shuts down once it has had no
+                sandboxes for this long (a billing backstop). Each sandbox also has its
+                own idle timeout, set at `create()`. Pass `None` to disable.
+            namespace (`str`, *optional*):
+                User or org namespace to run hosts under.
+            start_timeout (`float`, *optional*, defaults to `120.0`):
+                Max seconds to wait for a host to become ready.
+            adopt_hosts (`str`, *optional*, defaults to `"own"`):
+                Which already-running hosts `create()` may pack onto. Hosts are found by
+                filtering Jobs on labels, and labels are set by whoever creates the Job — so a
+                label match is a claim, not proof. This decides how much more than the claim is
+                required:
+
+                - `"own"` (default): only Jobs this principal started, per the Jobs API's
+                  `initiator`. Safe in a shared namespace.
+                - `"namespace"`: any Job in the namespace carrying the pool's labels, provided
+                  its image, flavor, command and exposed URL all match. Restores cross-user
+                  host sharing; only use it in a namespace whose members you trust, since any
+                  of them can publish a Job your client will then send a token to.
+                - `"never"`: no adoption at all — this handle only uses hosts it booted itself.
+            token (`str`, *optional*):
+                HF token override.
+        """
+        if adopt_hosts not in (ADOPT_OWN, ADOPT_NAMESPACE, ADOPT_NEVER):
+            raise ValueError(
+                f"adopt_hosts must be one of {ADOPT_OWN!r}, {ADOPT_NAMESPACE!r}, {ADOPT_NEVER!r}; got {adopt_hosts!r}."
+            )
+        if sandboxes_per_host < 1:
+            raise ValueError("sandboxes_per_host must be >= 1.")
+        if warm_up < 1:
+            raise ValueError("warm_up must be >= 1.")
+        self._api = HfApi(token=token)
+        self.image = image
+        self.flavor = flavor
+        self.sandboxes_per_host = sandboxes_per_host
+        self._warm_up = warm_up
+        self.max_hosts = max_hosts
+        self.name = name if name is not None else f"pool-{token_hex(6)}"
+        self._idle_timeout = idle_timeout
+        self._namespace = namespace
+        # Security context the local cache is keyed by: entries written by another endpoint,
+        # credential or namespace are a miss, not a hit (see `CacheContext`).
+        self._cache_context = _cache_context(self._api, namespace)
+        self._start_timeout = start_timeout
+        self._adopt_hosts = adopt_hosts
+        # Resolved lazily and only when `adopt_hosts="own"` needs it: whoami() is
+        # heavily rate-limited, and a pool that never discovers never needs it.
+        self._principal: str | None = None
+        self._principal_resolved = False
+        self._hosts: List[_SandboxServer] = []
+        self._lock = threading.Lock()
+        # Held across the whole one-time warm-up so concurrent first create() calls block until
+        # it finishes (and see the warm hosts) instead of racing past a half-set flag.
+        self._warmup_lock = threading.Lock()
+        # Serializes on-demand host creation within the process: a burst of create() calls that
+        # all find every host full boots one host at a time (each new host frees
+        # `sandboxes_per_host` slots for the threads still queued behind the lock) instead of
+        # one host per thread. The CLI is a single process per command, so this is a no-op there.
+        self._boot_lock = threading.Lock()
+        self._closed = False
+        # Whether the one-time warm-up (seed cache + pre-provision `warm_up` hosts) ran.
+        self._warmed_up = False
+        # Set for connect()'d handles: the pool must already exist, so create() refuses to
+        # silently resurrect it by booting a fresh host if discovery confirms every host is gone.
+        # Such a handle also never boots during construction — it attaches lazily on create().
+        self._require_live_host = _connect_mode
+        # Whether close()/`__exit__` cancels the host jobs. True for a pool we created; False
+        # for a connect()'d handle, which only releases its HTTP clients on exit — the shared
+        # hosts (possibly serving other clients) are left running, like Sandbox.connect().
+        # Kept as the default for hosts this handle boots (a connect()'d handle
+        # boots nothing during construction), but teardown is decided per host.
+        self._owns_hosts = not _connect_mode
+        # In-flight create/boot operations. `close()` waits for these to drain, so
+        # a host booted by a create() that was already past its closed check
+        # cannot land in a list nobody will ever tear down.
+        self._in_flight = 0
+        self._drained = threading.Condition(self._lock)
+        # Job ids of cached hosts we found dead this session; pruned from the cache on save.
+        self._dead_host_ids: set[str] = set()
+
+        # Pre-provision `warm_up` hosts now so the constructor returns only once the pool is
+        # warm. A connect()'d handle skips this: it must never boot during construction (it can
+        # only attach to existing hosts, lazily on the first create()).
+        if not _connect_mode:
+            self._ensure_warmed_up()
+
+    # ------------------------------------------------------------------ public API
+
+    @classmethod
+    def connect(
+        cls,
+        pool_id: str,
+        *,
+        namespace: str | None = None,
+        adopt_hosts: str = ADOPT_OWN,
+        token: str | None = None,
+    ) -> "SandboxPool":
+        """Reattach to a running pool by id, from any machine — no local state needed.
+
+        Finds a running host labelled with `pool_id` and rebuilds the pool's config
+        (image/flavor/density/host-idle) from that host job's spec and env vars, returning
+        a [`SandboxPool`] ready to `create()` more sandboxes — packing onto the running
+        hosts, or booting a duplicate (same config) when they are full.
+
+        Raises [`SandboxError`] if no running host is found (a pool stops existing once
+        all of its hosts are gone — idle-timed-out or killed).
+
+        Args:
+            pool_id (`str`):
+                The id returned when the pool was first created.
+            namespace (`str`, *optional*):
+                Namespace to search for the pool's hosts (defaults to yours).
+            adopt_hosts (`str`, *optional*, defaults to `"own"`):
+                Which hosts may be attached to. See [`SandboxPool`]. Reattaching to a pool whose
+                hosts another member of the namespace started needs `"namespace"`.
+            token (`str`, *optional*):
+                HF token override.
+        """
+        api = HfApi(token=token)
+        # Fast path: rebuild the pool from the local best-effort cache, with no HTTP at all.
+        # Only an entry written by this endpoint, credential and namespace is a hit (see
+        # `CacheContext`), so `namespace=` is honoured rather than being overridden by whatever
+        # the file says -- a `connect(namespace="org-B")` can no longer be served org-A's hosts.
+        # The cached hosts are seeded (and validated) lazily on the next create(); if they are
+        # all stale, create() falls back to label discovery exactly like a cold connect would.
+        cache = read_pool_cache(pool_id, _cache_context(api, namespace))
+        if cache is not None:
+            return cls(
+                image=cache.image,
+                flavor=cache.flavor,
+                sandboxes_per_host=cache.sandboxes_per_host,
+                max_hosts=cache.max_hosts,
+                name=pool_id,
+                idle_timeout=cache.idle_timeout,
+                namespace=namespace,
+                adopt_hosts=adopt_hosts,
+                token=token,
+                _connect_mode=True,  # attach to existing hosts; never boot during construction
+            )
+
+        # Cold path: find a running host via labels and rebuild the config from its job spec.
+        job = _find_pool_host_job(api, pool_id, namespace=namespace, policy=adopt_hosts)
+        env = _host_env(api, job, namespace=namespace)
+        idle_raw = env.get("SBX_IDLE_TIMEOUT")
+        max_hosts_raw = env.get("SBX_MAX_HOSTS")
+        return cls(
+            image=job.docker_image or job.space_id or DEFAULT_IMAGE,
+            flavor=str(job.flavor) if job.flavor is not None else "cpu-basic",
+            sandboxes_per_host=int(env.get("SBX_CAPACITY", DEFAULT_SANDBOXES_PER_HOST)),
+            max_hosts=int(max_hosts_raw) if max_hosts_raw is not None else None,
+            name=pool_id,
+            idle_timeout=int(idle_raw) if idle_raw is not None else None,
+            namespace=namespace,
+            adopt_hosts=adopt_hosts,
+            token=token,
+            _connect_mode=True,  # attach to existing hosts; never boot during construction
+        )
+
+    def warm(self, num_hosts: int = 1) -> List[str]:
+        """Ensure `num_hosts` empty host(s) are running and leave them running. Returns the
+        pool's host job ids.
+
+        Used to "create" a pool up front: the hosts carry the pool label and config (in
+        their env vars), so a later `SandboxPool.connect(pool_id)` (even from another
+        machine) finds them and spawns sandboxes without a cold start. The hosts keep
+        billing until killed or idle.
+
+        Adopts hosts already running for this pool (found via job labels) before booting,
+        so a `warm()` after `connect()` — or a repeated `warm()` — tops up to `num_hosts`
+        instead of duplicating live hosts and blowing past `max_hosts`.
+        """
+        if self._closed:
+            raise SandboxError("This SandboxPool is closed.")
+        self._discover_hosts()
+        with self._lock:
+            shortfall = num_hosts - len(self._hosts)
+        if shortfall > 0:
+            booted = self._provision_hosts(shortfall, allow_partial=True)
+            with self._lock:
+                self._hosts.extend(booted)
+        with self._warmup_lock:
+            self._warmed_up = True  # explicit warm-up satisfies create()'s one-time warm-up
+        self._save_cache()
+        return self.host_ids
+
+    def create(
+        self,
+        *,
+        env: dict[str, Any] | None = None,
+        idle_timeout: int | float | str | None = DEFAULT_IDLE_TIMEOUT,
+        forward_hf_token: bool = False,
+    ) -> "Sandbox":
+        """Create one sandbox, provisioning a host if needed.
+
+        Reuses a host with free capacity (this pool's, or a warm host found via job labels
+        / the local cache) before booting a new one, so a `create()` against a warm host
+        costs ~one round-trip. Call it repeatedly to fan out; use `warm_up` (or [`warm`])
+        to pre-provision hosts and avoid a cold start on the first calls. If a host fills
+        up under us (another process packed it) or a cached host is gone, the sandbox is
+        re-placed on another host (or a fresh one).
+
+        Args:
+            env (`dict[str, Any]`, *optional*):
+                Environment variables for this sandbox (each sandbox gets its own).
+            idle_timeout (`int` or `float` or `str`, *optional*, defaults to `600`):
+                Per-sandbox idle timeout — a sandbox is evicted from its host
+                after this much inactivity (no API calls, no running process). Distinct
+                from the host idle timeout. Pass `None` to disable.
+            forward_hf_token (`bool`, *optional*, defaults to `False`):
+                If True, inject your HF token as `HF_TOKEN` in the sandbox
+                (opt-in). Unlike a dedicated sandbox's `secrets`, a pooled sandbox's env is
+                delivered to the host server at creation (never stored in the host job), so
+                it doesn't appear in any job's metadata.
+        """
+        with self._lock:
+            if self._closed:
+                raise SandboxError("This SandboxPool is closed.")
+            # Registered under the lock together with the closed check, so
+            # `close()` cannot snapshot the host list between the two.
+            self._in_flight += 1
+        try:
+            return self._create_locked(env, idle_timeout, forward_hf_token)
+        finally:
+            with self._lock:
+                self._in_flight -= 1
+                self._drained.notify_all()
+
+    def _create_locked(
+        self,
+        env: dict[str, Any] | None,
+        idle_timeout: int | float | str | None,
+        forward_hf_token: bool,
+    ) -> "Sandbox":
+        sandbox_env = dict(env or {})
+        if forward_hf_token:
+            sandbox_env["HF_TOKEN"] = _effective_token(self._api)
+        # None disables per-sandbox idle eviction (mirrors Sandbox.create): leave it out of
+        # the create body entirely rather than sending 0, which the server reads as "evict now".
+        idle_secs = _duration_to_secs(idle_timeout) if idle_timeout is not None else None
+
+        new_hosts: List[_SandboxServer] = []
+        discovered = False
+        rounds = 0
+        try:
+            # One-time warm-up: seed from cache (no HTTP) and pre-provision `warm_up` hosts.
+            # Warm-up hosts are pool-level (like `warm()`), so they survive a failed create().
+            self._ensure_warmed_up()
+            while True:
+                # 1. Reserve a slot on a host we already track.
+                host = self._reserve_one()
+                # 2. If none free, attach (once) to warm hosts discovered via labels.
+                if host is None and not discovered:
+                    discovered = True
+                    self._discover_hosts()
+                    host = self._reserve_one()
+                # 3. Still none? Boot one host (unless we must not resurrect a dead pool).
+                if host is None:
+                    if self._require_live_host and discovered and not self._hosts:
+                        # connect()'d to a pool whose hosts are all gone (stale cache + nothing
+                        # found via labels): don't resurrect it under the same id, just report it.
+                        delete_pool_cache(self.name, self._cache_context)
+                        raise SandboxError(
+                            f"No running host found for pool '{self.name}'. The pool has stopped "
+                            "(all its hosts were killed or idle-timed-out); create a new one."
+                        )
+                    host = self._boot_one_host(new_hosts)
+                # 4. Create the sandbox on the reserved host. `None` means the host filled up
+                #    (another process packed it) or a stale cached host is gone — retry.
+                if host is not None:
+                    try:
+                        sandbox = self._create_one(host, sandbox_env, idle_secs)
+                    except Exception:
+                        # The create POST failed on a live host: release the slot we optimistically
+                        # reserved so the host isn't left permanently one sandbox short.
+                        with self._lock:
+                            host.live = max(0, host.live - 1)
+                        raise
+                    if sandbox is not None:
+                        self._save_cache()
+                        return sandbox
+                    # sandbox is None: the host is full (packed by another process) or gone.
+                    # Either way it's no longer a host we exclusively own, so stop tracking it
+                    # for teardown — cancelling it on a later round's failure would kill another
+                    # tenant's sandboxes (full host) or hit an already-dead job (gone host).
+                    if host in new_hosts:
+                        new_hosts.remove(host)
+                discovered = False  # re-scan for room / boot a host next round
+                rounds += 1
+                if rounds > _MAX_PACK_ROUNDS:
+                    raise SandboxError(
+                        "Could not place sandbox: hosts kept reporting full. Raise max_hosts or sandboxes_per_host."
+                    )
+        except Exception:
+            # All-or-nothing: tear down hosts we booted in this call.
+            with self._lock:
+                self._hosts = [h for h in self._hosts if h not in new_hosts]
+            for host in new_hosts:
+                try:
+                    host.cancel_job()
+                except Exception:
+                    pass
+                finally:
+                    host.close()
+            raise
+
+    @property
+    def num_hosts(self) -> int:
+        """Number of host jobs currently provisioned."""
+        with self._lock:
+            return len(self._hosts)
+
+    @property
+    def num_sandboxes(self) -> int:
+        """Number of sandboxes currently handed out (across all hosts)."""
+        with self._lock:
+            return sum(host.live for host in self._hosts)
+
+    @property
+    def host_ids(self) -> List[str]:
+        """Job ids of the provisioned hosts."""
+        with self._lock:
+            return [host.job_id for host in self._hosts]
+
+    def close(self) -> None:
+        """Release the pool. Idempotent.
+
+        For a pool we created, this terminates all host jobs (and therefore all their
+        sandboxes). For a `connect()`'d handle it only releases the local HTTP clients: the
+        shared hosts may be serving other clients, so — like [`Sandbox.connect`] — leaving a
+        `with` block must not tear them down. Terminate a connected pool's hosts explicitly
+        with `hf sandbox pool delete <id>`.
+
+        Only hosts *this handle started* are cancelled. A host discovered via labels may
+        be serving another process' sandboxes, so it is released rather than terminated.
+
+        Raises [`SandboxError`] if a host job could not be cancelled, naming the jobs that
+        are still running — they keep billing, and their cache entries are kept so they stay
+        discoverable. When `close()` is reached through `__exit__` with an exception already
+        in flight, the failure is logged instead, so it cannot mask the original error.
+        """
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            # Wait for in-flight creates so a host booted by one that was already
+            # past its closed check lands in `self._hosts` before the snapshot,
+            # rather than being orphaned. Bounded, because a wedged create must
+            # not hang process exit.
+            drain_timeout = self._start_timeout + _CLOSE_DRAIN_TIMEOUT
+            if self._in_flight and not self._drained.wait_for(lambda: self._in_flight == 0, timeout=drain_timeout):
+                logger.warning(
+                    f"Pool '{self.name}': {self._in_flight} operation(s) still in flight after "
+                    f"{drain_timeout}s; any host they boot will keep running."
+                )
+            hosts = self._hosts
+            self._hosts = []
+
+        survivors: List[_SandboxServer] = []
+        failures: List[str] = []
+        for host in hosts:
+            try:
+                # Only what this handle started. A discovered host may be serving
+                # someone else's sandboxes, and cancelling it kills them.
+                if host.owned:
+                    host.cancel_job()
+            except Exception as e:
+                # Keep it in the cache: that record is the user's only handle on a
+                # job that is still running and still billing.
+                survivors.append(host)
+                failures.append(f"{host.job_id} ({e})")
+                logger.warning(f"Failed to cancel sandbox host {host.job_id}: {e}")
+            finally:
+                host.close()
+
+        if survivors:
+            # Rewrite rather than delete, so the survivors stay discoverable.
+            self._save_cache(hosts=survivors)
+        elif self._owns_hosts:
+            # The pool's hosts are gone; don't leave a stale entry.
+            delete_pool_cache(self.name, self._cache_context)
+        if failures:
+            raise SandboxError(
+                f"Pool '{self.name}' could not terminate host job(s): {'; '.join(failures)}. "
+                "They are still running and billing; cancel them with `hf jobs cancel <id>`."
+            )
+
+    def __enter__(self) -> "SandboxPool":
+        return self
+
+    def __exit__(self, *exc_info) -> None:
+        try:
+            self.close()
+        except SandboxError:
+            # Never let a teardown failure mask the exception that is already
+            # propagating out of the `with` block.
+            if exc_info[0] is None:
+                raise
+            logger.warning(f"Pool '{self.name}' teardown failed while handling another error.", exc_info=True)
+
+    # ------------------------------------------------------------------ internals
+
+    def _ensure_warmed_up(self) -> None:
+        """One-time: seed from the cache and pre-provision up to `warm_up` hosts.
+
+        Cheap by default: seeding is local (no HTTP), and if the cache already gives at
+        least `warm_up` hosts we trust them and skip discovery/booting (dead ones are
+        pruned lazily by `create()`). Only when short do we list_jobs and boot the
+        shortfall in parallel, capped by `max_hosts`.
+
+        Runs at most once per pool, under `_warmup_lock`: concurrent first `create()` calls
+        block here until the warm-up completes — and see its hosts — rather than racing past
+        a half-set flag and each booting their own. `_warmed_up` is only set once the work
+        succeeds, so a failed warm-up is retried (seeding/discovery dedupe by job id).
+
+        Warm-up hosts are pool-level (like [`warm`]): they are not torn down if the
+        triggering `create()` later fails — `close()` (or the `with` block) reclaims them.
+        """
+        with self._warmup_lock:
+            if self._warmed_up:
+                return
+            self._seed_hosts_from_cache()
+            target = self._warm_up if self.max_hosts is None else min(self._warm_up, self.max_hosts)
+            with self._lock:
+                shortfall = target - len(self._hosts)
+            if shortfall > 0:
+                self._discover_hosts()
+                # A connect()'d pool must never boot during warm-up: it may only attach to
+                # existing hosts. Booting is left to create()'s loop, guarded by
+                # `_require_live_host`, so a stopped pool is reported instead of resurrected.
+                if not self._require_live_host:
+                    with self._lock:
+                        shortfall = target - len(self._hosts)
+                    if shortfall > 0:
+                        booted = self._provision_hosts(shortfall, allow_partial=True)
+                        with self._lock:
+                            self._hosts.extend(booted)
+            self._warmed_up = True
+        # Persist the warmed hosts so the next process (e.g. `hf sandbox create --pool` after a
+        # bare `hf sandbox pool create`) hits the cache fast path instead of re-discovering.
+        if self._hosts:
+            self._save_cache()
+
+    def _principal_id(self) -> str | None:
+        """Id of the principal this pool authenticates as, for the `"own"` policy."""
+        if not self._principal_resolved:
+            try:
+                self._principal = self._api.whoami(cache=True).get("id")
+                self._principal_resolved = self._principal is not None
+            except Exception as e:
+                # Leave it None: `_adoptable` then refuses rather than guessing.
+                logger.warning(f"Could not resolve the current user to validate pool hosts: {e}")
+        return self._principal
+
+    def _adoptable(self, job: JobInfo) -> bool:
+        """Whether `job` may be adopted as one of this pool's hosts."""
+        reason = _host_rejection(
+            job,
+            policy=self._adopt_hosts,
+            principal_id=self._principal_id() if self._adopt_hosts == ADOPT_OWN else None,
+            namespace=self._namespace,
+            image=self.image,
+            flavor=self.flavor,
+        )
+        if reason is not None:
+            logger.debug(f"Not adopting job {job.id} as a host for pool '{self.name}': {reason}.")
+            return False
+        return True
+
+    def _adoptable_pending(self, job: JobInfo) -> bool:
+        """Like `_adoptable`, minus the checks a not-yet-running job cannot pass."""
+        reason = _host_rejection(
+            job,
+            policy=self._adopt_hosts,
+            principal_id=self._principal_id() if self._adopt_hosts == ADOPT_OWN else None,
+            namespace=self._namespace,
+            image=self.image,
+            flavor=self.flavor,
+            check_url=False,
+        )
+        if reason is not None:
+            logger.debug(f"Not waiting for job {job.id} as a host for pool '{self.name}': {reason}.")
+            return False
+        return True
+
+    def _reserve_one(self) -> "_SandboxServer | None":
+        """Reserve one slot on the first host with free capacity (under lock), else None."""
+        with self._lock:
+            for host in self._hosts:
+                if host.capacity - host.live > 0:
+                    host.live += 1
+                    return host
+        return None
+
+    def _boot_one_host(self, new_hosts: List["_SandboxServer"]) -> "_SandboxServer | None":
+        """Provision (or adopt) one host and reserve a slot on it. Returns None to retry.
+
+        Held under `_boot_lock` so that, within a process, only one host is booted at a time:
+        a burst of create() calls that all found every host full queue here, and each new host
+        frees `sandboxes_per_host` slots for the threads still waiting — so they reuse it instead
+        of each booting their own. Before booting, we reuse a slot freed by a concurrent boot and,
+        failing that, adopt a host already SCHEDULING for this pool (here or in another process)
+        rather than piling on a duplicate.
+        """
+        with self._boot_lock:
+            # A concurrent boot (this process) may have added a host with free slots while we
+            # waited for the lock — reuse it instead of booting another.
+            host = self._reserve_one()
+            if host is not None:
+                return host
+            # A host already coming up for this pool (ours, or another process'): wait for it
+            # to start and adopt it instead of booting a duplicate.
+            if self._adopt_pending_host():
+                host = self._reserve_one()
+                if host is not None:
+                    return host
+            booted = self._provision_hosts(1)
+            new_hosts.extend(booted)
+            with self._lock:
+                self._hosts.extend(booted)
+            return self._reserve_one()
+
+    def _adopt_pending_host(self) -> bool:
+        """Wait for and adopt a host already SCHEDULING for this pool, if any.
+
+        Avoids over-provisioning when a host is already on its way up for this pool (started by
+        another process, or an earlier create() in this one): rather than booting a duplicate,
+        wait for it to reach RUNNING and adopt it via discovery. Returns True if a pending host
+        was found (whether or not it eventually came up), False if none is scheduling.
+        """
+        known = {host.job_id for host in self._hosts}
+        pending = next(
+            (
+                job
+                for job in self._api.list_jobs(
+                    status="SCHEDULING",
+                    labels={MODE_LABEL: MODE_POOL, POOL_LABEL: self.name},
+                    namespace=self._namespace,
+                )
+                # A SCHEDULING job has no exposed URL yet, so only the ownership
+                # and spec checks apply here; discovery re-validates it in full
+                # once it is RUNNING.
+                if job.id not in known and self._adoptable_pending(job)
+            ),
+            None,
+        )
+        if pending is None:
+            return False
+        logger.debug(f"Pool '{self.name}' host {pending.id} is already SCHEDULING; waiting for it instead of booting.")
+        deadline = time.time() + self._start_timeout
+        while time.time() < deadline:
+            stage = self._api.inspect_job(job_id=pending.id, namespace=self._namespace).status.stage
+            if stage not in ("SCHEDULING", "RUNNING"):
+                return False  # it died before starting up; let the caller boot a fresh one
+            if stage == "RUNNING":
+                # RUNNING precedes "server ready" (the host still has to fetch + exec sbx-server),
+                # so discovery only adopts it once its server answers — keep polling until it does.
+                self._discover_hosts()
+                if any(host.job_id == pending.id for host in self._hosts):
+                    return True
+            time.sleep(1.0)
+        return False
+
+    def _discover_hosts(self) -> None:
+        """Attach to running host jobs carrying this pool's labels.
+
+        Lets `create()` reuse a host warmed by an earlier call or another process
+        instead of booting a new one. Hosts are found via job labels; each adopted
+        host's free capacity is read from the server, so packing stays accurate.
+
+        Labels select candidates; creator, job specification and proxy URL admission
+        checks decide which candidates can receive credentials. Adopted hosts are released
+        by close(), not cancelled, because another handle may still be using them.
+        """
+        known = {host.job_id for host in self._hosts}
+        matches = [
+            job
+            for job in self._api.list_jobs(
+                status="RUNNING",
+                labels={MODE_LABEL: MODE_POOL, POOL_LABEL: self.name},
+                namespace=self._namespace,
+            )
+            if job.id not in known and self._adoptable(job)
+        ]
+
+        for job in matches:
+            server = None
+            try:
+                server = _connect_host(self._api, job.id, namespace=self._namespace)
+                # Capacity comes from the host's SBX_CAPACITY env; otherwise an adopted host
+                # would silently pack at the pool default and mis-pack.
+                env = _host_env(self._api, job, namespace=self._namespace)
+                server.capacity = int(env.get("SBX_CAPACITY", self.sandboxes_per_host))
+                server.live = len(server.request("GET", "/v1/sandboxes").json())
+            except (SandboxError, httpx2.HTTPError, HfHubHTTPError) as e:
+                # Host died (e.g. deleted between list_jobs and inspect_job), is still starting
+                # up, or is unreachable: skip it, closing the client if one was opened.
+                logger.debug(f"Skipping host {job.id} during discovery: {e}")
+                if server is not None:
+                    server.close()
+                continue
+            with self._lock:
+                if any(host.job_id == job.id for host in self._hosts):
+                    server.close()  # adopted concurrently by another thread
+                else:
+                    self._hosts.append(server)
+
+    def _live_host_count(self) -> int:
+        """How many hosts are running for this pool, not just the ones we track.
+
+        `max_hosts` is documented as a cost ceiling, but it was compared against
+        `len(self._hosts)` -- an in-process count. Two processes using the same
+        pool each counted only their own hosts, so the number of billed host jobs
+        could quietly exceed the cap by a factor of however many processes were
+        involved.
+
+        Counting via labels narrows that considerably. It does not close it: two
+        processes can still list simultaneously and both decide there is room. A
+        hard cap has to be enforced where the jobs are created, not by the
+        clients racing to count them.
+        """
+        with self._lock:
+            tracked = {host.job_id for host in self._hosts}
+        try:
+            for job in self._api.list_jobs(
+                status="RUNNING",
+                labels={MODE_LABEL: MODE_POOL, POOL_LABEL: self.name},
+                namespace=self._namespace,
+            ):
+                tracked.add(job.id)
+        except Exception as e:
+            # Fall back to the in-process count rather than refusing to boot.
+            logger.debug(f"Could not count live hosts for pool '{self.name}': {e}")
+        return len(tracked)
+
+    def _provision_hosts(self, num_new: int, *, allow_partial: bool = False) -> List[_SandboxServer]:
+        """Boot `num_new` host jobs in parallel, respecting `max_hosts`."""
+        if self.max_hosts is not None:
+            current = self._live_host_count()
+            if allow_partial:
+                num_new = min(num_new, max(0, self.max_hosts - current))
+            if current + num_new > self.max_hosts:
+                allowed = self.max_hosts - current
+                raise SandboxError(
+                    f"Pool needs {num_new} more host(s) but max_hosts={self.max_hosts} "
+                    f"allows only {max(0, allowed)} more ({current} already running for this pool). "
+                    "Raise max_hosts or kill some sandboxes."
+                )
+        if num_new == 0:
+            return []
+        # Boot in parallel, but collect every result before re-raising: if one boot fails,
+        # the others may have already started billable host jobs, so cancel those instead of
+        # leaking them (executor.map would surface the first error and drop the rest).
+        with ThreadPoolExecutor(max_workers=min(num_new, 32)) as executor:
+            futures = [executor.submit(self._boot_host) for _ in range(num_new)]
+        booted: List[_SandboxServer] = []
+        error: Exception | None = None
+        for future in futures:
+            try:
+                booted.append(future.result())
+            except Exception as e:
+                error = e
+        if error is not None:
+            for server in booted:
+                try:
+                    server.cancel_job()
+                except Exception:
+                    pass
+                finally:
+                    server.close()
+            raise error
+        return booted
+
+    def _boot_host(self) -> _SandboxServer:
+        """Start one host job and wait until its server is ready."""
+        hf_token = _effective_token(self._api)
+        nonce = token_hex(16)
+        sandbox_token = _derive_sandbox_token(hf_token, nonce)
+        command, job_env, job_secrets, job_volumes = _bootstrap_job_spec(
+            self._api,
+            hf_token,
+            env=None,  # host job carries no user env; sandboxes get env per create request
+            secrets=None,
+            volumes=None,
+            idle_timeout=self._idle_timeout,
+            forward_hf_token=False,
+            sandbox_token=sandbox_token,
+        )
+        # Host mode: per-sandbox idle eviction + empty-host shutdown (vs the dedicated
+        # whole-job watchdog).
+        job_env["SBX_HOST_MODE"] = "1"
+        # Server-authoritative packing cap: the host refuses creates past this (the client
+        # then packs onto / boots another host). Avoids cross-process over-commit. Read
+        # back (with SBX_IDLE_TIMEOUT) by `connect()` to rebuild the pool — labels stay for
+        # filtering only.
+        job_env["SBX_CAPACITY"] = str(self.sandboxes_per_host)
+        # Persist the optional cost ceiling on the host too, so a later connect() (e.g. the CLI
+        # `pool create --max-hosts N` then `create --pool <id>` flow) rebuilds the cap instead of
+        # defaulting to unlimited and provisioning past it.
+        if self.max_hosts is not None:
+            job_env["SBX_MAX_HOSTS"] = str(self.max_hosts)
+        labels = {SANDBOX_LABEL: "1", MODE_LABEL: MODE_POOL, POOL_LABEL: self.name, NONCE_LABEL: nonce}
+        job = self._api.run_job(
+            image=self.image,
+            command=command,
+            env=job_env,
+            secrets=job_secrets,
+            flavor=self.flavor,
+            timeout=SANDBOX_MAX_LIFETIME,
+            labels=labels,
+            volumes=job_volumes or None,
+            expose=[SANDBOX_SERVER_PORT],
+            namespace=self._namespace,
+        )
+        server: "_SandboxServer | None" = None
+        try:
+            # from_job is inside the try: if it raises (e.g. the server port isn't exposed),
+            # the already-started host job must still be cancelled so it doesn't linger billing.
+            server = _SandboxServer.from_job(
+                job=job,
+                nonce=nonce,
+                sandbox_token=sandbox_token,
+                api=self._api,
+                max_connections=min(self.sandboxes_per_host + 8, 256),
+                capacity=self.sandboxes_per_host,
+            )
+            server.wait_ready(self._start_timeout)
+        except Exception:
+            try:
+                self._api.cancel_job(job_id=job.id, namespace=job.owner.name)
+            except Exception as e:
+                logger.warning(f"Failed to cancel sandbox host {job.id} after startup failure: {e}")
+            if server is not None:
+                server.close()
+            raise
+        # We started this job, so this handle is the one that should end it.
+        server.owned = self._owns_hosts
+        return server
+
+    def _create_one(self, host: "_SandboxServer", env: dict[str, Any], idle_secs: int | None) -> "Sandbox | None":
+        """Create one sandbox on a reserved `host`. Returns the sandbox, or None to retry.
+
+        None means either the host filled up between our reservation and the create
+        (server-authoritative capacity — another client packed it, so we mark it full and
+        place the sandbox elsewhere) or a host rebuilt from the cache is gone/unreachable
+        (dropped and re-placed via discovery / a fresh boot).
+        """
+        body: dict[str, Any] = {"count": 1}
+        if idle_secs is not None:
+            body["idle_timeout_secs"] = idle_secs
+        if env:
+            body["env"] = env
+        try:
+            data = host.request("POST", "/v1/sandboxes", json=body).json()
+        except (SandboxError, httpx2.HTTPError) as e:
+            if host.verified:
+                raise  # a host we booted/discovered this session failing is a real error
+            logger.debug(f"Dropping unreachable cached host {host.job_id}: {e}")
+            self._drop_host(host)
+            return None
+        host.verified = True  # it answered, so it's a real live host now
+        sandboxes = data.get("sandboxes") or []
+        if int(data.get("rejected", 0)) or not sandboxes:
+            with self._lock:
+                host.live = host.capacity  # the host is full; stop reserving it
+            return None
+        item = sandboxes[0]
+        sandbox = Sandbox(
+            id=f"{host.job_id}{SHARED_ID_SEP}{item['id']}",
+            server=host,
+            local_id=item["id"],
+            owns_sandbox=True,
+            owns_server=False,
+            sandbox_token=item.get("token"),
+        )
+        sandbox._on_kill = self._on_sandbox_killed
+        return sandbox
+
+    def _on_sandbox_killed(self, sandbox: Sandbox) -> None:
+        """Free the packing slot of a shared sandbox that was killed."""
+        with self._lock:
+            sandbox._server.live = max(0, sandbox._server.live - 1)
+
+    def _drop_host(self, host: _SandboxServer) -> None:
+        """Forget a host found dead this session (and mark it for cache pruning)."""
+        with self._lock:
+            self._hosts = [h for h in self._hosts if h is not host]
+            self._dead_host_ids.add(host.job_id)
+        host.close()
+
+    # ------------------------------------------------------------------ cache (best effort)
+
+    def _seed_hosts_from_cache(self) -> None:
+        """Adopt the pool's cached hosts without any HTTP (rebuilt from cached URL + nonce).
+
+        The first thing that happens to a seeded host is an authenticated `POST`, so what the
+        file says about *where* it lives is not taken on trust: the URL must be one only this
+        job can have (`_cached_host_rejection`), and an entry older than `HOST_TRUST_TTL` is
+        re-checked against the Jobs API first (`_confirm_cached_host`). A fresh entry — the
+        `pool create` → `create --pool` case the cache exists for — is used as is.
+
+        Liveness stays best-effort: a seeded host is confirmed by its first successful request
+        and dropped on the first failure (see `_create_one`). Hosts the cache believes are
+        full are skipped — label discovery re-checks them with fresh counts if the seeded ones
+        don't satisfy the request, so a stale-full entry never blocks a create.
+        """
+        cache = read_pool_cache(self.name, self._cache_context)
+        if cache is None:
+            return
+        hf_token = _effective_token(self._api)
+        now = time.time()
+        for ch in cache.hosts:
+            with self._lock:
+                known = {host.job_id for host in self._hosts}
+            if ch.job_id in known or ch.live >= ch.capacity:
+                continue
+            reason = _cached_host_rejection(ch)
+            if reason is not None:
+                logger.debug(f"Dropping cached host {ch.job_id} of pool '{self.name}': it {reason}.")
+                with self._lock:
+                    self._dead_host_ids.add(ch.job_id)  # an entry we can never use is litter
+                continue
+            if now - ch.updated_at > HOST_TRUST_TTL and not self._confirm_cached_host(ch):
+                continue
+            server = _SandboxServer(
+                job_id=ch.job_id,
+                owner=ch.owner,
+                image=self.image,
+                base_url=ch.base_url,
+                nonce=ch.nonce,
+                sandbox_token=_derive_sandbox_token(hf_token, ch.nonce),
+                api=self._api,
+                max_connections=min(self.sandboxes_per_host + 8, 256),
+                capacity=ch.capacity,
+            )
+            server.live = ch.live
+            server.verified = False
+            with self._lock:
+                if any(host.job_id == ch.job_id for host in self._hosts):
+                    server.close()  # seeded concurrently by another thread
+                else:
+                    self._hosts.append(server)
+
+    def _confirm_cached_host(self, ch: CachedHost) -> bool:
+        """Confirm an aged-out cache entry against the Jobs API before crediting it.
+
+        Freshness is what the no-HTTP path rests on: the entry was written by this same
+        principal minutes ago, so the job it names is almost certainly still the host it
+        described. Past `HOST_TRUST_TTL` that argument weakens, and the entry becomes a hint
+        that has to be checked — the job must still be running, still be labelled for *this*
+        pool with the nonce the entry derives its token from, still pass the pool's adoption
+        policy, and still expose exactly the cached URL. One round-trip, and only for entries
+        the fast path would no longer be honest about.
+
+        A definitive "no" prunes the entry; a transient failure aborts this attempt
+        without losing the cached host.
+        """
+        if self._adopt_hosts == ADOPT_OWN and self._principal_id() is None:
+            raise SandboxError("Could not validate cached pool hosts: current user is unavailable; retry later.")
+        try:
+            job = self._api.inspect_job(job_id=ch.job_id, namespace=ch.owner)
+            labels = job.labels or {}
+            if job.status.stage != "RUNNING":
+                reason = f"its job is not running (status: {job.status.stage})"
+            elif labels.get(MODE_LABEL) != MODE_POOL or labels.get(POOL_LABEL) != self.name:
+                reason = f"its job is not labelled as a host of pool '{self.name}'"
+            elif labels.get(NONCE_LABEL) != ch.nonce:
+                reason = "its job carries a different nonce"
+            elif not self._adoptable(job):
+                reason = "its job is not one this pool may adopt"
+            elif (exposed := _find_server_url(job)) != ch.base_url:
+                reason = f"its job exposes {exposed!r}, not the cached URL"
+            else:
+                return True
+        except httpx2.HTTPStatusError as e:
+            if e.response.status_code != 404:
+                raise SandboxError(f"Could not confirm cached host {ch.job_id}; retry later.") from e
+            reason = "its job no longer exists"
+        except Exception as e:
+            raise SandboxError(f"Could not confirm cached host {ch.job_id}; retry later.") from e
+        logger.debug(f"Dropping stale cached host {ch.job_id} of pool '{self.name}': {reason}.")
+        with self._lock:
+            self._dead_host_ids.add(ch.job_id)
+        return False
+
+    def _save_cache(self, hosts: "List[_SandboxServer] | None" = None) -> None:
+        """Persist the pool config + hosts (with their live counts) for next time.
+
+        `hosts` overrides the tracked list, for the one case where they differ:
+        `close()` persisting the hosts it could *not* cancel, since that record is
+        the caller's only handle on a job that is still billing.
+        """
+        with self._lock:
+            source = self._hosts if hosts is None else hosts
+            entries = [
+                CachedHost(
+                    job_id=host.job_id,
+                    owner=host.owner,
+                    base_url=host.base_url,
+                    nonce=host.nonce,
+                    capacity=host.capacity,
+                    live=host.live,
+                    updated_at=time.time(),
+                )
+                for host in source
+            ]
+            dead = set(self._dead_host_ids)
+        save_pool_cache(
+            self.name,
+            context=self._cache_context,
+            image=self.image,
+            flavor=self.flavor,
+            sandboxes_per_host=self.sandboxes_per_host,
+            max_hosts=self.max_hosts,
+            idle_timeout=_duration_to_secs(self._idle_timeout) if self._idle_timeout is not None else None,
+            hosts=entries,
+            dead_host_ids=dead,
+        )
+
+
+def _normalize_image(image: str | None) -> str | None:
+    """Compare Docker images leniently: registries and tags get normalized
+    server-side, and a mis-parse here must not stop a pool from working."""
+    if image is None:
+        return None
+    image = image.strip().lower()
+    for prefix in ("docker.io/", "index.docker.io/", "library/"):
+        if image.startswith(prefix):
+            image = image[len(prefix) :]
+    return image
+
+
+def _server_host_rejection(url: str, *, job_id: str) -> str | None:
+    """Why `url` is not a URL we should send a sandbox job's credentials to.
+
+    The hostname must be derived from the job id we already hold, so nothing but the
+    client's own knowledge of which job it is talking to can decide where the credentials
+    go. The domain is not hard-coded, so staging endpoints keep working.
+    """
+    parsed = urlparse(url)
+    if parsed.scheme != "https":
+        return f"uses scheme {parsed.scheme!r}, not https"
+    # `urlparse` lowercases the hostname, so compare case-insensitively.
+    if not (parsed.hostname or "").startswith(f"{job_id}--{SANDBOX_SERVER_PORT}.".lower()):
+        return f"is not job {job_id}'s port-{SANDBOX_SERVER_PORT} URL"
+    return None
+
+
+def _server_url_rejection(job: JobInfo) -> str | None:
+    """Why this Job's exposed URL is not one we should send credentials to."""
+    urls = list(job.status.expose_urls or []) if job.status is not None else []
+    if len(urls) != 1:
+        return f"exposes {len(urls)} URL(s), expected exactly one for port {SANDBOX_SERVER_PORT}"
+    reason = _server_host_rejection(urls[0], job_id=job.id)
+    return f"exposes {urls[0]!r}, which {reason}" if reason is not None else None
+
+
+def _cached_host_rejection(host: CachedHost) -> str | None:
+    """Why a cached host entry must not be rebuilt into a credentialed transport.
+
+    Same reasoning as `_server_url_rejection`, for a URL that comes off the local disk
+    instead of the Jobs API. Without this, the cache file gets to choose where the HF bearer
+    and the derived host token are sent -- `http://127.0.0.1:1234` included -- and it gets to
+    choose it *before* any API call could have contradicted it. Deriving the expected
+    hostname from the entry's own `job_id` leaves it able to name only a job this client can
+    independently identify, which is the same bar a discovered host has to clear.
+    """
+    reason = _server_host_rejection(host.base_url, job_id=host.job_id)
+    return f"names {host.base_url!r}, which {reason}" if reason is not None else None
+
+
+def _cache_context(api: HfApi, namespace: str | None) -> CacheContext:
+    """The local pool cache's security context for this endpoint/credential/namespace."""
+    return CacheContext.for_credential(endpoint=api.endpoint, token=_effective_token(api), namespace=namespace)
+
+
+def _host_rejection(
+    job: JobInfo,
+    *,
+    policy: str,
+    principal_id: str | None,
+    namespace: str | None,
+    image: str | None,
+    flavor: str | None,
+    check_url: bool = True,
+) -> str | None:
+    """Why this Job must not be adopted as one of our pool hosts, or `None`.
+
+    Hosts are found by filtering Jobs on labels, and labels are set by whoever
+    creates the Job -- so a label match says "this Job claims to be one of our
+    hosts", not "this Job is one of our hosts". Anyone who can create a Job in
+    the namespace can make that claim, copy the public nonce from a real host's
+    labels, and receive the token derived for that host.
+
+    Everything checked here is asserted by the backend rather than by the Job's
+    creator: the initiator, the owner, the image, the flavor, the command, and
+    the exposed URL. `initiator` is the load-bearing one -- there is no
+    client-side way to set it -- and it is what makes `policy="own"` meaningful.
+    """
+    if policy == ADOPT_NEVER:
+        return "host adoption is disabled (adopt_hosts='never')"
+
+    if policy == ADOPT_OWN:
+        initiator = job.initiator
+        if initiator is None or initiator.id is None:
+            return "the Jobs API did not say who started it, so it cannot be confirmed as ours"
+        if principal_id is None:
+            return "could not resolve the current principal to compare against its initiator"
+        if initiator.id != principal_id:
+            return f"started by a different principal ({initiator.name or initiator.id})"
+
+    if namespace is not None and job.owner is not None and job.owner.name != namespace:
+        return f"runs under namespace {job.owner.name!r}, not {namespace!r}"
+
+    job_image = job.docker_image or job.space_id
+    if image is not None and _normalize_image(job_image) != _normalize_image(image):
+        return f"runs image {job_image!r}, not {image!r}"
+
+    if flavor is not None and str(job.flavor) != flavor:
+        return f"runs flavor {str(job.flavor)!r}, not {flavor!r}"
+
+    # A sandbox host runs the bootstrap script and nothing else. A Job running
+    # anything else is not a host, whatever its labels say.
+    if job.command is None or list(job.command) != _bootstrap_command():
+        return "does not run the sandbox bootstrap command"
+
+    # A SCHEDULING job has no exposed URL yet; the caller re-checks once it runs.
+    return _server_url_rejection(job) if check_url else None
+
+
+def _effective_token(api: HfApi) -> str:
+    token = api.token if isinstance(api.token, str) else get_token()
+    if not token:
+        raise SandboxError("A Hugging Face token is required to use sandboxes. Run `hf auth login` first.")
+    return token
+
+
+def _bootstrap_job_spec(
+    api: HfApi,
+    hf_token: str,
+    *,
+    env: dict[str, Any] | None,
+    secrets: dict[str, Any] | None,
+    volumes: List[Volume] | None,
+    idle_timeout: int | float | str | None,
+    forward_hf_token: bool,
+    sandbox_token: str,
+) -> tuple[list[str], dict[str, Any], dict[str, Any], List[Volume]]:
+    """Build the (command, env, secrets, volumes) to launch a job running sbx-server.
+
+    Shared by dedicated sandboxes and shared hosts: both fetch and exec the same unified
+    `sbx-server` binary at startup (via `/bin/sh`), downloading it with wget/curl, or
+    reading it off the always-mounted server bucket when the image ships neither. Either
+    way the download is pinned to `SANDBOX_SERVER_SHA256` and verified before it runs.
+    """
+    # Reserved SBX_* keys go last so user-provided env/secrets can't override them
+    # (e.g. clobbering SBX_PORT would break the proxy, SBX_TOKEN would break auth).
+    job_env: dict[str, Any] = {**(env or {}), "SBX_PORT": str(SANDBOX_SERVER_PORT)}
+    job_secrets: dict[str, Any] = {**(secrets or {}), "SBX_TOKEN": sandbox_token}
+    job_volumes = list(volumes or [])
+    if idle_timeout is not None:
+        job_env["SBX_IDLE_TIMEOUT"] = str(_duration_to_secs(idle_timeout))
+    if forward_hf_token:
+        job_secrets["HF_TOKEN"] = hf_token
+
+    # The digest-named object, not the mutable `sbx-server` alias: a fetch that names the
+    # content it wants cannot be answered with different content, and the bootstrap re-checks
+    # the digest anyway so a rewritten object is caught rather than executed.
+    server_object = f"sbx-server-{SANDBOX_SERVER_SHA256}"
+    job_env["SBX_SERVER_URL"] = f"{api.endpoint}/buckets/{constants.SANDBOX_SERVER_BUCKET}/resolve/{server_object}"
+    job_env["SBX_SERVER_SHA256"] = SANDBOX_SERVER_SHA256
+    # Always mount the server bucket as a transparent fallback for images without wget/curl.
+    # It's only read (paying the ~2-3s FUSE cost) when the bootstrap script can't download.
+    job_env["SBX_SERVER_MOUNT"] = _SERVER_MOUNT_PATH
+    job_volumes.append(
+        Volume(type="bucket", source=constants.SANDBOX_SERVER_BUCKET, mount_path=_SERVER_MOUNT_PATH, read_only=True)
+    )
+    return _bootstrap_command(), job_env, job_secrets, job_volumes
+
+
+def _bootstrap_command() -> list[str]:
+    """The Job command every sandbox host and dedicated sandbox runs."""
+    return ["/bin/sh", "-c", _BOOTSTRAP_DOWNLOAD]
+
+
+def _host_env(api: HfApi, job: JobInfo, *, namespace: str | None) -> dict[str, Any]:
+    """Return a host job's env vars (where pool config lives)"""
+    env = job.environment if isinstance(job.environment, dict) else {}
+    if "SBX_CAPACITY" not in env:
+        env = api.inspect_job(job_id=job.id, namespace=namespace).environment or {}
+        env = env if isinstance(env, dict) else {}
+    return env
+
+
+def _find_pool_host_job(api: HfApi, pool_id: str, *, namespace: str | None = None, policy: str = ADOPT_OWN) -> JobInfo:
+    """Return a running host job belonging to `pool_id`, found via the pool label.
+
+    This one feeds `SandboxPool.connect`'s cold path, which rebuilds the pool's
+    whole configuration (image, flavor, density, caps) from the job it returns --
+    so an unvalidated match would let a Job in the namespace choose the image
+    that the pool's *next* hosts boot. Image and flavor are unknown here (they
+    are what we are about to learn), so this checks ownership and shape.
+    """
+    principal = None
+    if policy == ADOPT_OWN:
+        try:
+            principal = api.whoami(cache=True).get("id")
+        except Exception as e:
+            logger.warning(f"Could not resolve the current user to validate pool hosts: {e}")
+    rejected = []
+    for job in api.list_jobs(
+        status="RUNNING", labels={MODE_LABEL: MODE_POOL, POOL_LABEL: pool_id}, namespace=namespace
+    ):
+        reason = _host_rejection(
+            job, policy=policy, principal_id=principal, namespace=namespace, image=None, flavor=None
+        )
+        if reason is None:
+            return job
+        rejected.append(f"{job.id} ({reason})")
+    if rejected:
+        raise SandboxError(
+            f"Found host job(s) labelled for pool '{pool_id}' but none usable: {'; '.join(rejected)}. "
+            "Pass adopt_hosts='namespace' to SandboxPool if you intend to share hosts with other "
+            "members of this namespace."
+        )
+    raise SandboxError(
+        f"No running host found for pool '{pool_id}'. The pool has stopped "
+        "(all its hosts were killed or idle-timed-out); create a new one."
+    )
+
+
+def _connect_host(api: HfApi, host_job_id: str, *, namespace: str | None = None) -> _SandboxServer:
+    """Reattach to a running host job and return its server transport."""
+    job = api.inspect_job(job_id=host_job_id, namespace=namespace)
+    labels = job.labels or {}
+    nonce = labels.get(NONCE_LABEL)
+    if nonce is None or labels.get(MODE_LABEL) != MODE_POOL:
+        raise SandboxError(f"Job {host_job_id} is not a sandbox host.")
+    if job.status.stage != "RUNNING":
+        raise SandboxError(f"Sandbox host {host_job_id} is not running (status: {job.status.stage}).")
+    # The caller named this job explicitly, so who started it is their call --
+    # but the credentials below must still only reach this job's own URL, over
+    # HTTPS, on a job that actually runs the sandbox bootstrap.
+    reason = _host_rejection(
+        job, policy=ADOPT_NAMESPACE, principal_id=None, namespace=namespace, image=None, flavor=None
+    )
+    if reason is not None:
+        raise SandboxError(f"Job {host_job_id} does not look like a usable sandbox host: {reason}.")
+    return _SandboxServer.from_job(
+        job=job,
+        nonce=nonce,
+        sandbox_token=_derive_sandbox_token(_effective_token(api), nonce),
+        api=api,
+        max_connections=SandboxFiles.PARALLEL_MAX_WORKERS + 2,
+    )
+
+
+def _split_sandbox_id(sandbox_id: str, namespace: str | None) -> tuple[str, str | None]:
+    """Accept `namespace/sandbox_id` ids (as shown in the Hub UI), like `hf jobs` does."""
+    if "/" not in sandbox_id:
+        return sandbox_id, namespace
+    extracted_namespace, parsed_id = sandbox_id.split("/", 1)
+    if not extracted_namespace or not parsed_id or "/" in parsed_id:
+        raise SandboxError(f"Sandbox id must be 'sandbox_id' or 'namespace/sandbox_id', got {sandbox_id!r}.")
+    if namespace is not None and namespace != extracted_namespace:
+        raise SandboxError(
+            f"Conflicting namespace: got namespace={namespace!r} but sandbox id implies namespace={extracted_namespace!r}."
+        )
+    return parsed_id, extracted_namespace
+
+
+def _find_server_url(job: JobInfo) -> str:
+    for url in job.status.expose_urls or []:
+        if f"--{SANDBOX_SERVER_PORT}." in url:
+            return url
+    raise SandboxError(f"Job {job.id} does not expose the sandbox server port {SANDBOX_SERVER_PORT}.")
+
+
+def _tail_job_logs(api: HfApi, job_id: str, *, namespace: str | None = None, limit: int = 20) -> str:
+    try:
+        lines = list(api.fetch_job_logs(job_id=job_id, namespace=namespace))[-limit:]
+    except Exception:
+        return ""
+    return " Last logs:\n" + "\n".join(f"  {line}" for line in lines) if lines else ""
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox_cache.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..310a8359bc775404ef4b6b13bf517373af815771
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_sandbox_cache.py
@@ -0,0 +1,351 @@
+# coding=utf-8
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Best-effort local cache for SandboxPool hosts (host/pool mode)."""
+
+import hashlib
+import json
+import os
+import re
+import tempfile
+import time
+from dataclasses import asdict, dataclass, field
+from pathlib import Path
+from typing import Any, List
+
+from . import constants
+from .utils import WeakFileLock, logging
+
+
+logger = logging.get_logger(__name__)
+
+# Bump if the on-disk layout changes incompatibly; older/newer files are ignored on read.
+_CACHE_VERSION = 2
+
+# A write should never block a sandbox creation for long: the cache is best-effort, so we
+# rather skip persisting than wait on a stuck lock.
+_LOCK_TIMEOUT = 5.0
+
+# How long a cached host may be turned into a credentialed transport on the strength of the
+# file alone. Within it, the `pool create` -> `create --pool` sequence stays at zero extra
+# round-trips (the point of the cache); past it, the caller re-checks the host against the
+# Jobs API before sending it anything.
+HOST_TRUST_TTL = 15 * 60
+
+# The cache holds reusable host URLs and the public nonces the host tokens derive from, so
+# both the directories and the files are private to the user.
+_DIR_MODE = 0o700
+
+# Domain separation, so a digest from this cache is not also a digest of the same material
+# computed for some other purpose (and so a version bump renames every directory).
+_DIGEST_PREFIX = f"hf-sandbox-pool-cache/v{_CACHE_VERSION}"
+
+# Plausibility bounds for the schema check below. Generous on purpose: this is here to turn a
+# wrong-typed or absurd value into a cache miss, not to re-specify the pool's own limits.
+_MAX_COUNT = 1_000_000
+_MAX_SECONDS = 10 * 365 * 24 * 3600
+_MAX_TIMESTAMP = 4_000_000_000  # epoch seconds, some time in 2096
+_MAX_STR = 2048
+# Job ids are backend-assigned; the id also feeds a URL and an `inspect_job` call, so keep it
+# to characters that cannot change the meaning of either.
+_JOB_ID_RE = re.compile(r"[A-Za-z0-9._-]{1,128}")
+# Nonces are minted by `token_hex(16)`; the bounds are loose so that changing that length
+# would not quietly turn every cache entry into a miss.
+_NONCE_RE = re.compile(r"[0-9a-fA-F]{16,128}")
+
+
+def _digest(*parts: str) -> str:
+    """Short, stable digest of `parts` (which are joined unambiguously)."""
+    material = "\x00".join((_DIGEST_PREFIX, *parts))
+    return hashlib.sha256(material.encode()).hexdigest()
+
+
+@dataclass(frozen=True)
+class CacheContext:
+    """The security context a cache entry belongs to.
+
+    A cached entry is not just data: the fast path rebuilds a host transport from it and
+    sends it the HF bearer plus the derived host token. So it may only ever be read back by
+    the same *endpoint*, *credential* and *namespace* that wrote it -- anything else is a
+    plain cache miss, which is what the docs promise and what keeps a `connect(namespace=...)`
+    from being served hosts that belong to another namespace.
+
+    `principal` is an opaque, stable id for the credential; the token itself is never stored
+    nor used as a key (see `for_credential`).
+    """
+
+    endpoint: str
+    principal: str
+    namespace: str | None
+
+    @classmethod
+    def for_credential(cls, *, endpoint: str, token: str, namespace: str | None) -> "CacheContext":
+        """Build the context of a given HF token, identified by its fingerprint.
+
+        The fingerprint is a local computation, which is what keeps a cache hit at zero
+        round-trips -- resolving the credential to a user id would cost a `whoami` and defeat
+        the purpose of the cache. It is derived from the token but does not contain it: only
+        the digest is ever written to disk.
+
+        A rotated or swapped credential therefore reads as a different principal and gets a
+        cache miss (the cold path, which always works), rather than someone else's hosts.
+        """
+        return cls(endpoint=endpoint, principal=_digest("principal", token)[:32], namespace=namespace)
+
+    @property
+    def key(self) -> str:
+        """Digest of the whole context; the name of the cache subdirectory it owns."""
+        return _digest("context", self.endpoint, self.principal, self.namespace or "")[:16]
+
+
+@dataclass
+class CachedHost:
+    """A single host Job of a pool, as last seen by some process.
+
+    `base_url` + `nonce` are everything needed to rebuild the in-job server transport
+    (`_SandboxServer`) without an `inspect_job` round-trip: the per-sandbox auth token is
+    re-derived from the user's HF token and `nonce` (see `_derive_sandbox_token`).
+    """
+
+    job_id: str
+    owner: str  # namespace the host job runs under (for cancel/inspect)
+    base_url: str  # exposed sbx-server URL (does not change while the job lives)
+    nonce: str  # public nonce from the job label; derives the sandbox auth token
+    capacity: int  # SBX_CAPACITY: max sandboxes the host packs
+    live: int  # sandboxes last observed on the host (best-effort, may be stale)
+    updated_at: float = 0.0
+
+
+@dataclass
+class PoolCache:
+    """Cached view of one pool: its config (to boot new hosts) + its known hosts."""
+
+    pool_id: str
+    image: str
+    flavor: str
+    sandboxes_per_host: int
+    max_hosts: int | None
+    idle_timeout: int | None
+    namespace: str | None
+    # Context the entry was written in, so a file that is moved (or copied from elsewhere)
+    # into a directory it was not written for is still rejected. See `CacheContext`.
+    endpoint: str = ""
+    context: str = ""
+    hosts: List[CachedHost] = field(default_factory=list)
+    version: int = _CACHE_VERSION
+    updated_at: float = 0.0
+
+
+def _pools_dir() -> Path:
+    return Path(constants.HF_HOME) / "sandbox" / "pools"
+
+
+def _check_pool_id(pool_id: str) -> str:
+    """Return `pool_id` if it is safe to use as a file name, else raise."""
+    if any(c in pool_id for c in ("/", "\\", "\x00")) or pool_id in (".", ".."):
+        raise ValueError(f"Invalid pool id: {pool_id!r}")
+    return pool_id
+
+
+def pool_cache_path(pool_id: str, context: CacheContext) -> Path:
+    """Path of the cache file for `pool_id` in `context` (no I/O)."""
+    return _pools_dir() / context.key / f"{_check_pool_id(pool_id)}.json"
+
+
+def read_pool_cache(pool_id: str, context: CacheContext) -> PoolCache | None:
+    """Return the cached view of `pool_id` for `context`, or `None`.
+
+    Missing, corrupt, incompatible, mistyped and foreign-context files are all the same thing
+    here: a cache miss, logged at debug level. The caller's cold path is always correct, so
+    this never raises -- a bad cache costs latency, never an error mid-`create()`.
+    """
+    try:
+        path = pool_cache_path(pool_id, context)
+        with path.open("r", encoding="utf-8") as f:
+            data = json.load(f)
+        if data.get("version") != _CACHE_VERSION:
+            return None
+        hosts = [CachedHost(**h) for h in data.pop("hosts", [])]
+        cache = PoolCache(**data, hosts=hosts)
+    except FileNotFoundError:
+        return None
+    except Exception as e:
+        logger.debug(f"Ignoring unreadable sandbox pool cache for {pool_id!r}: {e}")
+        return None
+    reason = _cache_rejection(cache, pool_id=pool_id, context=context)
+    if reason is not None:
+        logger.debug(f"Ignoring sandbox pool cache for {pool_id!r}: {reason}.")
+        return None
+    return cache
+
+
+def save_pool_cache(
+    pool_id: str,
+    *,
+    context: CacheContext,
+    image: str,
+    flavor: str,
+    sandboxes_per_host: int,
+    max_hosts: int | None,
+    idle_timeout: int | None,
+    hosts: List[CachedHost],
+    dead_host_ids: set[str] | None = None,
+) -> None:
+    """Merge `hosts` into the cache for `pool_id` in `context` (best-effort, never raises).
+
+    Concurrency-safe: under a file lock, the on-disk hosts are read, then `hosts` are
+    upserted by `job_id` and `dead_host_ids` removed, so a process only adds/updates what
+    it learned and never drops hosts another process discovered. The result is written
+    atomically. The pool config is refreshed from the arguments.
+    """
+    dead = dead_host_ids or set()
+    try:
+        path = pool_cache_path(pool_id, context)
+        _ensure_private_dir(path.parent)
+        with WeakFileLock(str(path) + ".lock", timeout=_LOCK_TIMEOUT):
+            existing = read_pool_cache(pool_id, context)
+            merged = {h.job_id: h for h in (existing.hosts if existing else [])}
+            for host in hosts:
+                merged[host.job_id] = host
+            for job_id in dead:
+                merged.pop(job_id, None)
+            cache = PoolCache(
+                pool_id=pool_id,
+                image=image,
+                flavor=flavor,
+                sandboxes_per_host=sandboxes_per_host,
+                max_hosts=max_hosts,
+                idle_timeout=idle_timeout,
+                namespace=context.namespace,
+                endpoint=context.endpoint,
+                context=context.key,
+                hosts=list(merged.values()),
+                updated_at=time.time(),
+            )
+            _atomic_write(path, cache)
+    except Exception as e:
+        logger.debug(f"Could not write sandbox pool cache for {pool_id!r}: {e}")
+
+
+def delete_pool_cache(pool_id: str, context: CacheContext | None = None) -> None:
+    """Remove the cache file(s) for `pool_id` (best-effort, never raises).
+
+    Without a `context`, the pool's entry is removed from *every* context: deleting a pool is
+    the one operation for which over-deleting is the safe direction (the cache is disposable),
+    and the caller may not know which credential wrote the entry.
+    """
+    try:
+        if context is not None:
+            pool_cache_path(pool_id, context).unlink(missing_ok=True)
+            return
+        filename = f"{_check_pool_id(pool_id)}.json"
+        for directory in _pools_dir().iterdir():
+            if directory.is_dir():
+                (directory / filename).unlink(missing_ok=True)
+    except Exception as e:
+        logger.debug(f"Could not delete sandbox pool cache for {pool_id}: {e}")
+
+
+def _ensure_private_dir(path: Path) -> None:
+    """Create the cache directory tree, readable by this user only.
+
+    `mkdir`'s mode is masked by the umask and the tree may predate this code, so the modes
+    are also set explicitly, from the leaf up to (and including) the sandbox directory.
+    """
+    path.mkdir(parents=True, exist_ok=True, mode=_DIR_MODE)
+    root = Path(constants.HF_HOME) / "sandbox"
+    for directory in (path, *path.parents):
+        if directory != root and root not in directory.parents:
+            break  # $HF_HOME itself (and anything above it) is not ours to re-mode
+        os.chmod(directory, _DIR_MODE)
+
+
+def _atomic_write(path: Path, cache: PoolCache) -> None:
+    """Write the cache via a temp file + `os.replace` so readers never see a partial file.
+
+    `mkstemp` gives the temp file an unpredictable name and mode `0600` regardless of the
+    umask (which `os.replace` then carries over to the final file), so no other user can read
+    -- or pre-create and win a race on -- the host URLs and nonces on their way to disk.
+    """
+    fd, tmp = tempfile.mkstemp(dir=path.parent, prefix=path.name + ".", suffix=".tmp")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as f:
+            json.dump(asdict(cache), f, indent=2)
+        os.replace(tmp, path)
+    except BaseException:
+        Path(tmp).unlink(missing_ok=True)
+        raise
+
+
+def _is_count(value: Any, *, minimum: int = 0, maximum: int = _MAX_COUNT) -> bool:
+    """Whether `value` is a plausible count. `bool` is an `int`, but not a count."""
+    return isinstance(value, int) and not isinstance(value, bool) and minimum <= value <= maximum
+
+
+def _is_timestamp(value: Any) -> bool:
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and 0 <= value <= _MAX_TIMESTAMP
+
+
+def _is_text(value: Any, *, allow_empty: bool = False) -> bool:
+    return isinstance(value, str) and (allow_empty or len(value) > 0) and len(value) <= _MAX_STR
+
+
+def _cache_rejection(cache: PoolCache, *, pool_id: str, context: CacheContext) -> str | None:
+    """Why this cache file must not be used, or `None` if it may be.
+
+    Two jobs. First, the entry has to belong to the caller's security context -- same
+    endpoint, same credential, same namespace -- which is what makes a cross-namespace or
+    cross-principal hit a miss instead of a confidentiality bug.
+
+    Second, a schema check. `dataclass` does not enforce types, so a well-shaped file with
+    `"capacity": "50"` parses happily and only blows up much later, on `host.capacity -
+    host.live`, as an uncaught `TypeError` in the middle of `create()`. Validating here turns
+    that into the documented cache miss.
+    """
+    if cache.context != context.key:
+        return "it was written for a different endpoint, credential or namespace"
+    if cache.endpoint != context.endpoint:
+        return f"it names endpoint {cache.endpoint!r}, not {context.endpoint!r}"
+    if cache.namespace != context.namespace:
+        return f"it names namespace {cache.namespace!r}, not {context.namespace!r}"
+    if cache.pool_id != pool_id:
+        return f"it names pool {cache.pool_id!r}, not {pool_id!r}"
+
+    if not _is_text(cache.image) or not _is_text(cache.flavor):
+        return "its image/flavor are not strings"
+    if not _is_count(cache.sandboxes_per_host, minimum=1):
+        return f"its sandboxes_per_host is not a positive count: {cache.sandboxes_per_host!r}"
+    if cache.max_hosts is not None and not _is_count(cache.max_hosts, minimum=1):
+        return f"its max_hosts is not a positive count: {cache.max_hosts!r}"
+    if cache.idle_timeout is not None and not _is_count(cache.idle_timeout, maximum=_MAX_SECONDS):
+        return f"its idle_timeout is not a duration in seconds: {cache.idle_timeout!r}"
+    if not _is_timestamp(cache.updated_at):
+        return f"its updated_at is not a timestamp: {cache.updated_at!r}"
+
+    if not isinstance(cache.hosts, list):
+        return "its hosts are not a list"
+    for host in cache.hosts:
+        if not _JOB_ID_RE.fullmatch(host.job_id if isinstance(host.job_id, str) else ""):
+            return f"host {host.job_id!r} is not a plausible job id"
+        if not _JOB_ID_RE.fullmatch(host.owner if isinstance(host.owner, str) else ""):
+            return f"host {host.job_id} names a non-namespace owner: {host.owner!r}"
+        if not _is_text(host.base_url):
+            return f"host {host.job_id} has no URL"
+        if not isinstance(host.nonce, str) or not _NONCE_RE.fullmatch(host.nonce):
+            return f"host {host.job_id} has no usable nonce"
+        if not _is_count(host.capacity) or not _is_count(host.live):
+            return f"host {host.job_id} has a non-numeric capacity/live count"
+        if not _is_timestamp(host.updated_at):
+            return f"host {host.job_id} has no usable timestamp"
+    return None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py
new file mode 100644
index 0000000000000000000000000000000000000000..82971f4ae016296374ff98f2a76ca5efd015716f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_snapshot_download.py
@@ -0,0 +1,708 @@
+import os
+from pathlib import Path
+from typing import Literal, overload
+
+import httpx2
+from tqdm.auto import tqdm as base_tqdm
+
+from . import constants
+from ._revision import ResolvedRevision
+from ._tree_cache import TreeCacheEntry, read_tree_cache, tree_cache_folder_for_local_dir, write_tree_cache
+from .errors import (
+    CachedRepoTreeNotFoundError,
+    DryRunError,
+    GatedRepoError,
+    HfHubHTTPError,
+    IncompleteSnapshotError,
+    LocalEntryNotFoundError,
+    RepositoryNotFoundError,
+    RevisionNotFoundError,
+)
+from .file_download import (
+    REGEX_COMMIT_HASH,
+    DryRunFileInfo,
+    _cache_commit_hash_for_specific_revision,
+    hf_hub_download,
+    repo_folder_name,
+)
+from .hf_api import HfApi, RepoFile
+from .utils import OfflineModeIsEnabled, filter_repo_objects, logging, validate_hf_hub_args
+from .utils._http import flag_as_download_call
+from .utils._paths import as_extended_path
+from .utils._xet_progress_reporting import (
+    XET_BYTES_BAR_FORMAT,
+    XET_TRANSFER_BAR_FORMAT,
+    _finish_transfer_bar,
+    _set_aggregate_rate_postfix,
+    _update_transfer_bar,
+)
+from .utils.tqdm import _create_progress_bar, hf_thread_map
+from .utils.tqdm import tqdm as hf_tqdm
+
+
+logger = logging.get_logger(__name__)
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: Literal[False] = False,
+) -> str: ...
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: Literal[True] = True,
+) -> list[DryRunFileInfo]: ...
+
+
+@overload
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: bool = False,
+) -> str | list[DryRunFileInfo]: ...
+
+
+@validate_hf_hub_args
+@flag_as_download_call
+def snapshot_download(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+    library_name: str | None = None,
+    library_version: str | None = None,
+    user_agent: dict | str | None = None,
+    etag_timeout: float = constants.DEFAULT_ETAG_TIMEOUT,
+    force_download: bool = False,
+    token: bool | str | None = None,
+    local_files_only: bool = False,
+    allow_patterns: list[str] | str | None = None,
+    ignore_patterns: list[str] | str | None = None,
+    max_workers: int = 8,
+    tqdm_class: type[base_tqdm] | None = None,
+    headers: dict[str, str] | None = None,
+    endpoint: str | None = None,
+    dry_run: bool = False,
+) -> str | list[DryRunFileInfo]:
+    """Download repo files.
+
+    Download a whole snapshot of a repo's files at the specified revision. This is useful when you want all files from
+    a repo because you don't know which ones you will need _a priori_. All files are nested in a folder to keep their
+    path and filename relative to that folder. You can also filter which files to download by using `allow_patterns`
+    and `ignore_patterns`.
+
+    If `local_dir` is provided, the file structure from the repo will be replicated in this location. When using this
+    option, the `cache_dir` will not be used, and a `.cache/huggingface/` folder will be created at the root of `local_dir`
+    to store some metadata related to the downloaded files. While this mechanism is not as robust as the main
+    cache system, it's optimized for regularly pulling the latest version of a repository.
+
+    An alternative would be to clone the repo, but this requires git and git-lfs to be installed and properly
+    configured. It is also not possible to filter which files to download when cloning a repository using git.
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"`, `"space"` or `"kernel"` if downloading from a dataset, space or kernel repo,
+            `None` or `"model"` if downloading from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id, which can be a branch name, a tag, or a
+            commit hash.
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, the downloaded files will be placed under this directory.
+        library_name (`str`, *optional*):
+            The name of the library to which the object corresponds.
+        library_version (`str`, *optional*):
+            The version of the library.
+        user_agent (`str`, `dict`, *optional*):
+            The user-agent info in the form of a dictionary or a string.
+        etag_timeout (`float`, *optional*, defaults to `10`):
+            When fetching ETag, how many seconds to wait for the server to send
+            data before giving up, which is passed to `httpx2.request`.
+        force_download (`bool`, *optional*, defaults to `False`):
+            Whether the file should be downloaded even if it already exists in the local cache.
+        token (`str`, `bool`, *optional*):
+            A token to be used for the download.
+                - If `True`, the token is read from the HuggingFace config
+                  folder.
+                - If a string, it's used as the authentication token.
+        headers (`dict`, *optional*):
+            Additional headers to include in the request. Those headers take precedence over the others.
+        endpoint (`str`, *optional*):
+            The Hub endpoint to send the request to. Defaults to the value of `HF_ENDPOINT`.
+        local_files_only (`bool`, *optional*, defaults to `False`):
+            If `True`, do not download any files even if they are not in `cache_dir` or `local_dir`.
+        allow_patterns (`list[str]` or `str`, *optional*):
+            If provided, only files matching at least one pattern are downloaded.
+        ignore_patterns (`list[str]` or `str`, *optional*):
+            If provided, files matching any of the patterns are not downloaded.
+        max_workers (`int`, *optional*):
+            Number of concurrent threads to download files (1 thread = 1 file download).
+            Defaults to 8.
+        tqdm_class (`tqdm`, *optional*):
+            If provided, overwrites the default behavior for the progress bar. Passed
+            argument must inherit from `tqdm.auto.tqdm` or at least mimic its behavior.
+            Note that the `tqdm_class` is not passed to each individual download.
+            Defaults to the custom HF progress bar that can be disabled by setting
+            `HF_HUB_DISABLE_PROGRESS_BARS` environment variable.
+        dry_run (`bool`, *optional*, defaults to `False`):
+            If `True`, perform a dry run without actually downloading the files. Returns a list of
+            [`DryRunFileInfo`] objects containing information about what would be downloaded.
+
+    Returns:
+        `str` or list of [`DryRunFileInfo`]:
+            - If `dry_run=False`: Local snapshot path.
+            - If `dry_run=True`: A list of [`DryRunFileInfo`] objects containing download information.
+
+    Raises:
+        [`~utils.RepositoryNotFoundError`]
+            If the repository to download from cannot be found. This may be because it doesn't exist
+            or because it is set to `private` and you do not have access.
+        [`~utils.RevisionNotFoundError`]
+            If the revision to download from cannot be found.
+        [`~errors.IncompleteSnapshotError`]
+            If the Hub cannot be reached (offline, connection issue, or `local_files_only=True`) and the
+            cached snapshot is missing some of the requested files.
+        [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
+            If `token=True` and the token cannot be found.
+        [`OSError`](https://docs.python.org/3/library/exceptions.html#OSError) if
+            ETag cannot be determined.
+        [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
+            If some parameter value is invalid.
+    """
+    if cache_dir is None:
+        cache_dir = constants.HF_HUB_CACHE
+    cache_dir = str(Path(cache_dir).expanduser().resolve())
+    if local_dir is not None:
+        local_dir = str(Path(local_dir).expanduser().resolve())
+    if revision is None:
+        revision = constants.DEFAULT_REVISION
+
+    if repo_type is None:
+        repo_type = "model"
+    if repo_type not in constants.REPO_TYPES_WITH_KERNEL:
+        raise ValueError(
+            f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES_WITH_KERNEL)}"
+        )
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+
+    # Folder under which the per-commit tree listing (`trees/<commit_hash>.json`) is cached on disk.
+    tree_cache_folder = tree_cache_folder_for_local_dir(local_dir) if local_dir is not None else storage_folder
+
+    api = HfApi(
+        library_name=library_name,
+        library_version=library_version,
+        user_agent=user_agent,
+        endpoint=endpoint,
+        headers=headers,
+        token=token,
+    )
+
+    # The revision is already a commit hash if:
+    # - it's a `ResolvedRevision` (already resolved, see [`HfApi.resolve_revision`])
+    # - it's a commit hash, which is immutable
+    # => in both cases, there is nothing to resolve and the `repo_info` call can be skipped.
+    commit_hash: str | None = None
+    if isinstance(revision, ResolvedRevision):
+        commit_hash = revision.resolved
+    elif REGEX_COMMIT_HASH.fullmatch(revision):
+        commit_hash = revision
+
+    tree_entries: dict[str, TreeCacheEntry] | None = None
+    api_call_error: Exception | None = None
+    if not local_files_only:
+        # try/except logic to handle different errors => taken from `hf_hub_download`
+        try:
+            if commit_hash is None:
+                # if we have internet connection we want to list files to download
+                repo_info = api.repo_info(repo_id=repo_id, repo_type=repo_type, revision=revision)
+                assert repo_info.sha is not None, "Repo info returned from server must have a revision sha."
+                commit_hash = repo_info.sha
+            tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+            if tree_entries is None:
+                tree_entries = {
+                    f.path: TreeCacheEntry(
+                        size=f.size,
+                        blob_id=f.blob_id,
+                        lfs_sha256=f.lfs.sha256 if f.lfs is not None else None,
+                        lfs_size=f.lfs.size if f.lfs is not None else None,
+                        xet_hash=f.xet_hash,
+                    )
+                    for f in api.list_repo_tree(
+                        repo_id=repo_id, recursive=True, revision=commit_hash, repo_type=repo_type
+                    )
+                    if isinstance(f, RepoFile)
+                }
+                if not dry_run:
+                    write_tree_cache(tree_cache_folder, commit_hash, tree_entries)
+        except httpx2.ProxyError:
+            # Actually raise on proxy error
+            raise
+        except (httpx2.ConnectError, httpx2.TimeoutException, OfflineModeIsEnabled) as error:
+            # Internet connection is down
+            # => will try to use local files only
+            api_call_error = error
+            pass
+        except RevisionNotFoundError:
+            # The repo was found but the revision doesn't exist on the Hub (never existed or got deleted)
+            raise
+        except HfHubHTTPError as error:
+            # Multiple reasons for an http error:
+            # - Repository is private and invalid/missing token sent
+            # - Repository is gated and invalid/missing token sent
+            # - Hub is down (error 500 or 504)
+            # => let's switch to 'local_files_only=True' to check if the files are already cached.
+            #    (if it's not the case, the error will be re-raised)
+            api_call_error = error
+            pass
+
+    # At this stage, if the tree listing is unknown it means either:
+    # - internet connection is down
+    # - internet connection is deactivated (local_files_only=True or HF_HUB_OFFLINE=True)
+    # - repo is private/gated and invalid/missing token sent
+    # - Hub is down
+    # => let's look if we can find the appropriate folder in the cache:
+    #    - if the specified revision is a commit hash, look inside "snapshots".
+    #    - f the specified revision is a branch or tag, look inside "refs".
+    # => if local_dir is not None, we will return the path to the local folder if it exists.
+    if tree_entries is None or local_files_only:
+        if dry_run:
+            raise DryRunError(
+                "Dry run cannot be performed as the repository cannot be accessed. Please check your internet connection or authentication token."
+            ) from api_call_error
+
+        # Try to get which commit hash corresponds to the specified revision
+        if commit_hash is None:
+            ref_path = os.path.join(storage_folder, "refs", revision)
+            if os.path.exists(ref_path):
+                # retrieve commit_hash from refs file
+                with open(ref_path) as f:
+                    commit_hash = f.read()
+
+        # Try to locate snapshot folder for this commit hash
+        if commit_hash is not None and local_dir is None:
+            snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+            if os.path.exists(snapshot_folder):
+                # The folder exists, but may be partial (e.g. after an interrupted download): only return it
+                # if the cached tree listing confirms it is complete.
+                _raise_if_incomplete_snapshot(
+                    tree_cache_folder=tree_cache_folder,
+                    commit_hash=commit_hash,
+                    base_dir=snapshot_folder,
+                    allow_patterns=allow_patterns,
+                    ignore_patterns=ignore_patterns,
+                    repo_id=repo_id,
+                    revision=revision,
+                    api_call_error=api_call_error,
+                )
+                return snapshot_folder
+
+        # If local_dir is not None, return it if it exists and is complete
+        if local_dir is not None:
+            local_dir = Path(local_dir)
+            if local_dir.is_dir() and any(local_dir.iterdir()):
+                if commit_hash is not None:
+                    _raise_if_incomplete_snapshot(
+                        tree_cache_folder=tree_cache_folder,
+                        commit_hash=commit_hash,
+                        base_dir=str(local_dir),
+                        allow_patterns=allow_patterns,
+                        ignore_patterns=ignore_patterns,
+                        repo_id=repo_id,
+                        revision=revision,
+                        api_call_error=api_call_error,
+                    )
+                logger.warning(
+                    f"Returning existing local_dir `{local_dir}` as remote repo cannot be accessed in `snapshot_download` ({api_call_error})."
+                )
+                return str(local_dir.resolve())
+        # If we couldn't find the appropriate folder on disk, raise an error.
+        if local_files_only:
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, pass "
+                "'local_files_only=False' as input."
+            )
+        elif isinstance(api_call_error, OfflineModeIsEnabled):
+            raise LocalEntryNotFoundError(
+                "Cannot find an appropriate cached snapshot folder for the specified revision on the local disk and "
+                "outgoing traffic has been disabled. To enable repo look-ups and downloads online, set "
+                "'HF_HUB_OFFLINE=0' as environment variable."
+            ) from api_call_error
+        elif isinstance(api_call_error, (RepositoryNotFoundError, GatedRepoError)) or (
+            isinstance(api_call_error, HfHubHTTPError) and api_call_error.response.status_code == 401
+        ):
+            # Repo not found, gated, or specific authentication error => let's raise the actual error
+            raise api_call_error
+        else:
+            # Otherwise: most likely a connection issue or Hub downtime => let's warn the user
+            raise LocalEntryNotFoundError(
+                f"Got: {api_call_error.__class__.__name__}: {api_call_error}"
+                "\nAn error happened while trying to locate the files on the Hub, and we cannot find the appropriate"
+                " snapshot folder for the specified revision on the local disk. Please check your internet connection"
+                " and try again."
+            ) from api_call_error
+
+    # At this stage, the commit hash is known and internet connection is up and running
+    # => let's download the files!
+    assert commit_hash is not None
+
+    filtered_repo_files = list(
+        filter_repo_objects(
+            items=tree_entries.keys(),
+            allow_patterns=allow_patterns,
+            ignore_patterns=ignore_patterns,
+        )
+    )
+    if tree_entries and not filtered_repo_files and (allow_patterns is not None or ignore_patterns is not None):
+        provided_patterns = ", ".join(
+            f"{name}={value!r}"
+            for name, value in (("allow_patterns", allow_patterns), ("ignore_patterns", ignore_patterns))
+            if value is not None
+        )
+        logger.warning(f"No files matched {provided_patterns}.")
+    tqdm_desc = f"Fetching {len(filtered_repo_files)} files"
+    if dry_run:
+        tqdm_desc = "[dry-run] " + tqdm_desc
+
+    snapshot_folder = os.path.join(storage_folder, "snapshots", commit_hash)
+    # if passed revision is not identical to commit_hash
+    # then revision has to be a branch name or tag name.
+    # In that case store a ref (except if ResolvedRevision, in which case it's already done).
+    if not isinstance(revision, ResolvedRevision):
+        try:
+            # Skips the write if the ref is already up to date, and writes atomically otherwise so that
+            # concurrent readers never observe a truncated (empty) ref file.
+            _cache_commit_hash_for_specific_revision(storage_folder, revision, commit_hash)
+        except OSError as e:
+            logger.warning(
+                f"Ignored error while writing commit hash to {os.path.join(storage_folder, 'refs', revision)}: {e}."
+            )
+
+    results: list[str | DryRunFileInfo] = []
+
+    # User can use its own tqdm class or the default one from `huggingface_hub.utils`
+    tqdm_class = tqdm_class or hf_tqdm
+
+    # Create progress bars for the bytes downloaded.
+    # Transfer bytes are received from the network; reconstruction bytes are written to disk.
+    transfer_progress = _create_progress_bar(
+        cls=tqdm_class,
+        log_level=logger.getEffectiveLevel(),
+        name="huggingface_hub.snapshot_download.transfer",
+        desc="Downloading bytes",
+        total=0,
+        initial=0,
+        unit="B",
+        unit_scale=True,
+        bar_format=XET_TRANSFER_BAR_FORMAT,
+    )
+
+    reconstruct_progress = _create_progress_bar(
+        cls=tqdm_class,
+        log_level=logger.getEffectiveLevel(),
+        name="huggingface_hub.snapshot_download",
+        desc="Reconstructing (incomplete total...)",
+        total=0,
+        initial=0,
+        unit="B",
+        unit_scale=True,
+        bar_format=XET_BYTES_BAR_FORMAT,
+    )
+
+    class _AggregatedTqdm:
+        """Fake tqdm object to aggregate progress into the parent snapshot progress bars.
+
+        In practice, the `_AggregatedTqdm` object won't be displayed; it's just used to update
+        the `reconstruct_progress` and `transfer_progress` bars from each thread/file download.
+        """
+
+        def __init__(self, *args, **kwargs):
+            # Adjust the total of the parent progress bar
+            total = kwargs.pop("total", None)
+            if total is not None:
+                reconstruct_progress.total = (reconstruct_progress.total or 0) + total
+                transfer_progress.total = (transfer_progress.total or 0) + total
+                reconstruct_progress.refresh()
+
+            # Adjust initial of the parent progress bar
+            initial = kwargs.pop("initial", 0)
+            if initial:
+                reconstruct_progress.update(initial)
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+        def close(self) -> None:
+            pass
+
+        def update(self, n: int | float | None = 1) -> None:
+            reconstruct_progress.update(n)
+
+        def update_transfer(self, n: int | float | None = 1) -> None:
+            _update_transfer_bar(transfer_progress, int(n or 0))
+
+        def set_postfix_str(self, postfix: str, refresh: bool = False) -> None:
+            # Discard the caller's per-file rate; report the summed rate across all files instead.
+            _set_aggregate_rate_postfix(reconstruct_progress)
+
+        def set_transfer_postfix_str(self, postfix: str, refresh: bool = False) -> None:
+            _set_aggregate_rate_postfix(transfer_progress)
+
+    # Pass the commit_hash as revision to hf_hub_download to skip network call if:
+    # - file is cached
+    # - or xet file with metadata cached in /tree cache
+    def _inner_hf_hub_download(repo_file: str) -> None:
+        results.append(
+            hf_hub_download(  # type: ignore
+                repo_id,
+                filename=repo_file,
+                repo_type=repo_type,
+                revision=commit_hash,
+                endpoint=endpoint,
+                cache_dir=cache_dir,
+                local_dir=local_dir,
+                library_name=library_name,
+                library_version=library_version,
+                user_agent=user_agent,
+                etag_timeout=etag_timeout,
+                force_download=force_download,
+                token=token,
+                headers=headers,
+                tqdm_class=_AggregatedTqdm,  # type: ignore
+                dry_run=dry_run,
+            )
+        )
+
+    hf_thread_map(
+        _inner_hf_hub_download,
+        filtered_repo_files,
+        desc=tqdm_desc,
+        max_workers=max_workers,
+        tqdm_class=tqdm_class,
+    )
+
+    _finish_transfer_bar(transfer_progress)
+    transfer_progress.set_description_str("Download complete")
+    reconstruct_progress.set_description("Reconstruction complete")
+
+    if dry_run:
+        assert all(isinstance(r, DryRunFileInfo) for r in results)
+        return results  # type: ignore
+
+    if local_dir is not None:
+        return str(os.path.realpath(local_dir))
+    return snapshot_folder
+
+
+def _raise_if_incomplete_snapshot(
+    *,
+    tree_cache_folder: str,
+    commit_hash: str,
+    base_dir: str,
+    allow_patterns: list[str] | str | None,
+    ignore_patterns: list[str] | str | None,
+    repo_id: str,
+    revision: str,
+    api_call_error: Exception | None,
+) -> None:
+    """Raise [`IncompleteSnapshotError`] if the cached tree listing shows `base_dir` misses requested files.
+
+    If the tree listing is not cached we cannot tell, so we do nothing and the caller keeps returning the
+    folder as-is. Otherwise every expected file (after pattern filtering) must exist under `base_dir`.
+    """
+    tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+    if tree_entries is None:
+        return
+    expected = filter_repo_objects(
+        items=tree_entries.keys(), allow_patterns=allow_patterns, ignore_patterns=ignore_patterns
+    )
+    missing = [path for path in expected if not _local_file_exists(base_dir, path)]
+    if not missing:
+        return
+
+    sample = ", ".join(missing[:3])
+    if len(missing) > 3:
+        sample += f", ... ({len(missing) - 3} more)"
+    if api_call_error is not None:
+        reason = f"The Hub could not be reached ({api_call_error.__class__.__name__}: {api_call_error})."
+    else:
+        reason = "Outgoing traffic is disabled ('local_files_only=True')."
+    raise IncompleteSnapshotError(
+        f"The cached snapshot for '{repo_id}' (revision '{revision}', commit {commit_hash}) is incomplete: "
+        f"{len(missing)} file(s) are missing ({sample}). {reason} Re-run the download with network access "
+        "to complete the snapshot.",
+        snapshot_path=base_dir,
+    ) from api_call_error
+
+
+@validate_hf_hub_args
+def get_cached_repo_tree(
+    repo_id: str,
+    *,
+    repo_type: str | None = None,
+    revision: str | None = None,
+    cache_dir: str | Path | None = None,
+    local_dir: str | Path | None = None,
+) -> list[RepoFile]:
+    """Return the cached tree listing of a repo at a given revision, without any network call.
+
+    The tree listing is the set of files (with their download metadata) of a repo at a commit. It is populated
+    on disk as a side effect of [`snapshot_download`] (see the `trees/<commit_hash>.json` cache files) and is
+    used to skip network calls on subsequent downloads. This function exposes that cache directly.
+
+    If you need the current tree listing of a repo on the Hub, use [`list_repo_tree`] instead.
+
+    Args:
+        repo_id (`str`):
+            A user or an organization name and a repo name separated by a `/`.
+        repo_type (`str`, *optional*):
+            Set to `"dataset"`, `"space"` or `"kernel"` if listing from a dataset, space or kernel repo,
+            `None` or `"model"` if listing from a model. Default is `None`.
+        revision (`str`, *optional*):
+            An optional Git revision id, which can be a branch name, a tag, or a commit hash. Defaults to the
+            default branch. Branch/tag names are resolved to a commit hash using the local cache (`refs/`).
+        cache_dir (`str`, `Path`, *optional*):
+            Path to the folder where cached files are stored. Defaults to the value of `HF_HUB_CACHE`.
+        local_dir (`str` or `Path`, *optional*):
+            If provided, read the tree listing cached by a `local_dir` download (from
+            `local_dir/.cache/huggingface/`) instead of the main cache. Branch/tag revisions are still resolved
+            to a commit hash using the main cache (`cache_dir`).
+
+    Returns:
+        `list[RepoFile]`: The list of [`RepoFile`] objects cached for this revision.
+
+    Raises:
+        [`~errors.CachedRepoTreeNotFoundError`]
+            If no tree listing is cached for the requested revision (e.g. the repo was never downloaded at this revision).
+
+    Example:
+        ```py
+        >>> from huggingface_hub import get_cached_repo_tree
+        >>> files = get_cached_repo_tree("openai-community/gpt2")
+        >>> [f.path for f in files]
+        ['.gitattributes', 'config.json', 'model.safetensors', ...]
+        ```
+    """
+    if cache_dir is None:
+        cache_dir = constants.HF_HUB_CACHE
+    cache_dir = str(Path(cache_dir).expanduser().resolve())
+    if local_dir is not None:
+        local_dir = str(Path(local_dir).expanduser().resolve())
+    if revision is None:
+        revision = constants.DEFAULT_REVISION
+    if repo_type is None:
+        repo_type = constants.REPO_TYPE_MODEL
+    if repo_type not in constants.REPO_TYPES_WITH_KERNEL:
+        raise ValueError(
+            f"Invalid repo type: {repo_type}. Accepted repo types are: {str(constants.REPO_TYPES_WITH_KERNEL)}"
+        )
+
+    storage_folder = os.path.join(cache_dir, repo_folder_name(repo_id=repo_id, repo_type=repo_type))
+
+    # For `local_dir` downloads the tree listing lives under `local_dir/.cache/huggingface/`; otherwise it lives
+    # in the per-repo `storage_folder`. Refs are always recorded in the main cache, so we resolve them there.
+    tree_cache_folder = tree_cache_folder_for_local_dir(local_dir) if local_dir is not None else storage_folder
+
+    # The tree cache is keyed by commit hash. Resolve the revision to a commit hash: either it already is one,
+    # or it's a branch/tag name recorded in `refs/` by a previous download.
+    if isinstance(revision, ResolvedRevision):
+        commit_hash = revision.resolved
+    elif REGEX_COMMIT_HASH.fullmatch(revision):
+        commit_hash = revision
+    else:
+        ref_path = os.path.join(storage_folder, "refs", revision)
+        if not os.path.isfile(ref_path):
+            raise CachedRepoTreeNotFoundError(
+                f"No cached tree listing found for '{repo_id}' (revision '{revision}', repo_type '{repo_type}'): "
+                f"the revision is not a commit hash and no matching ref is cached in '{storage_folder}'. "
+                "Download the repo (e.g. with `snapshot_download`) to populate the cache first."
+            )
+        with open(ref_path) as f:
+            commit_hash = f.read()
+
+    tree_entries = read_tree_cache(tree_cache_folder, commit_hash)
+    if tree_entries is None:
+        raise CachedRepoTreeNotFoundError(
+            f"No cached tree listing found for '{repo_id}' (revision '{revision}', commit '{commit_hash}', "
+            f"repo_type '{repo_type}') in '{tree_cache_folder}'. Download the repo (e.g. with `snapshot_download`) "
+            "to populate the cache first."
+        )
+
+    return [
+        RepoFile(path=path, size=entry.size, oid=entry.blob_id, xetHash=entry.xet_hash)
+        for path, entry in tree_entries.items()
+    ]
+
+
+def _local_file_exists(base_dir: str, path: str) -> bool:
+    """Check whether a repo file (path relative to `base_dir`, '/'-separated) exists on disk.
+
+    On Windows, paths longer than 255 characters must be prefixed with `\\\\?\\`, otherwise `os.path.isfile` reports an
+    existing file as missing.
+    """
+    return os.path.isfile(as_extended_path(os.path.join(base_dir, *path.split("/"))))
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_space_api.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_space_api.py
new file mode 100644
index 0000000000000000000000000000000000000000..ea68812d02fd2395b055c3785e3809f2b7dd68ac
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_space_api.py
@@ -0,0 +1,430 @@
+# Copyright 2019-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Literal
+
+from huggingface_hub.utils import HfMount, HfUri, parse_datetime
+
+
+class SpaceStage(str, Enum):
+    """
+    Enumeration of possible stage of a Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStage.BUILDING == "BUILDING"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceInfo.ts#L61 (private url).
+    """
+
+    # Copied from moon-landing > server > repo_types > SpaceInfo.ts (private repo)
+    NO_APP_FILE = "NO_APP_FILE"
+    CONFIG_ERROR = "CONFIG_ERROR"
+    BUILDING = "BUILDING"
+    BUILD_ERROR = "BUILD_ERROR"
+    RUNNING = "RUNNING"
+    RUNNING_BUILDING = "RUNNING_BUILDING"
+    RUNTIME_ERROR = "RUNTIME_ERROR"
+    DELETING = "DELETING"
+    STOPPED = "STOPPED"
+    PAUSED = "PAUSED"
+    APP_STARTING = "APP_STARTING"
+    RUNNING_APP_STARTING = "RUNNING_APP_STARTING"
+
+
+INTERMEDIATE_SPACE_STAGES = (
+    SpaceStage.BUILDING,
+    SpaceStage.RUNNING_BUILDING,
+    SpaceStage.APP_STARTING,
+    SpaceStage.RUNNING_APP_STARTING,
+)
+
+TERMINAL_SPACE_STAGES = (
+    SpaceStage.RUNNING,
+    SpaceStage.BUILD_ERROR,
+    SpaceStage.RUNTIME_ERROR,
+    SpaceStage.CONFIG_ERROR,
+    SpaceStage.NO_APP_FILE,
+    SpaceStage.STOPPED,
+    SpaceStage.PAUSED,
+    SpaceStage.DELETING,
+)
+
+
+class SpaceHardware(str, Enum):
+    """
+    Enumeration of hardwares available to run your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceHardware.CPU_BASIC == "cpu-basic"
+    ```
+
+    Taken from https://github.com/huggingface-internal/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts (private url).
+    """
+
+    # CPU
+    CPU_BASIC = "cpu-basic"
+    CPU_UPGRADE = "cpu-upgrade"
+
+    # ZeroGPU
+    ZERO_A10G = "zero-a10g"
+
+    # GPU
+    T4_SMALL = "t4-small"
+    T4_MEDIUM = "t4-medium"
+    L4X1 = "l4x1"
+    L4X4 = "l4x4"
+    L40SX1 = "l40sx1"
+    L40SX4 = "l40sx4"
+    L40SX8 = "l40sx8"
+    A10G_SMALL = "a10g-small"
+    A10G_LARGE = "a10g-large"
+    A10G_LARGEX2 = "a10g-largex2"
+    A10G_LARGEX4 = "a10g-largex4"
+    A100_LARGE = "a100-large"
+    A100X4 = "a100x4"
+    A100X8 = "a100x8"
+
+
+class SpaceStorage(str, Enum):
+    """
+    Enumeration of persistent storage available for your Space on the Hub.
+
+    Value can be compared to a string:
+    ```py
+    assert SpaceStorage.SMALL == "small"
+    ```
+
+    Taken from https://github.com/huggingface/moon-landing/blob/main/server/repo_types/SpaceHardwareFlavor.ts#L24 (private url).
+    """
+
+    SMALL = "small"
+    MEDIUM = "medium"
+    LARGE = "large"
+
+
+@dataclass
+class Volume:
+    """
+    Describes a volume to mount in a Space or Job container.
+
+    Args:
+        type (`str`):
+            Type of volume: `"bucket"`, `"model"`, `"dataset"`, or `"space"`.
+        source (`str`):
+            Source identifier, e.g. `"username/my-bucket"` or `"username/my-model"`.
+        mount_path (`str`):
+            Mount path inside the container, e.g. `"/data"`. Must start with `/`.
+        revision (`str` or `None`):
+            Git revision (only for repos, defaults to `"main"`).
+        read_only (`bool` or `None`):
+            Read-only mount. Forced `True` for repos, defaults to `False` for buckets.
+        path (`str` or `None`):
+            Subfolder prefix inside the bucket/repo to mount, e.g. `"path/to/dir"`.
+    """
+
+    type: Literal["bucket", "model", "dataset", "space"]
+    source: str
+    mount_path: str
+    revision: str | None = None
+    read_only: bool | None = None
+    path: str | None = None
+
+    def __init__(self, **kwargs) -> None:
+        self.type = kwargs.get("type", "model")
+        self.source = kwargs["source"]
+        mount_path = kwargs.get("mountPath")
+        self.mount_path = mount_path if mount_path is not None else kwargs["mount_path"]
+        self.revision = kwargs.get("revision")
+        read_only = kwargs.get("readOnly")
+        self.read_only = read_only if read_only is not None else kwargs.get("read_only")
+        self.path = kwargs.get("path")
+
+    def to_dict(self) -> dict:
+        """Serialize to the JSON payload expected by the Hub API."""
+        data: dict = {
+            "type": self.type,
+            "source": self.source,
+            "mountPath": self.mount_path,
+        }
+        if self.revision is not None:
+            data["revision"] = self.revision
+        if self.read_only is not None:
+            data["readOnly"] = self.read_only
+        if self.path is not None:
+            data["path"] = self.path
+        return data
+
+    def to_uri(self) -> str:
+        """Return the volume as an HF mount URI in the format expected by the CLI."""
+        return HfMount(
+            source=HfUri(type=self.type, id=self.source, revision=self.revision, path_in_repo=self.path or ""),
+            mount_path=self.mount_path,
+            read_only=self.read_only,
+        ).to_uri()
+
+
+@dataclass
+class SpaceHotReloading:
+    status: Literal["created", "canceled"]
+    replica_statuses: list[tuple[str, str | None]]  # See _hot_reloading_types.ApiCreateReloadResponse.res.status
+    raw: dict
+
+    def __init__(self, data: dict) -> None:
+        self.status = data["status"]
+        self.replica_statuses = data["replicaStatuses"]
+        self.raw = data
+
+
+@dataclass
+class SpaceRuntime:
+    """
+    Contains information about the current runtime of a Space.
+
+    Args:
+        stage (`str`):
+            Current stage of the space. Example: RUNNING.
+        hardware (`str` or `None`):
+            Current hardware of the space. Example: "cpu-basic". Can be `None` if Space
+            is `BUILDING` for the first time.
+        requested_hardware (`str` or `None`):
+            Requested hardware. Can be different from `hardware` especially if the request
+            has just been made. Example: "t4-medium". Can be `None` if no hardware has
+            been requested yet.
+        sleep_time (`int` or `None`):
+            Number of seconds the Space will be kept alive after the last request. By default (if value is `None`), the
+            Space will never go to sleep if it's running on an upgraded hardware, while it will go to sleep after 48
+            hours on a free 'cpu-basic' hardware. For more details, see https://huggingface.co/docs/hub/spaces-gpus#sleep-time.
+        volumes (`list[Volume]` or `None`):
+            List of volumes mounted in the Space. Each volume is a [`Volume`] object describing its type, source,
+            mount path, and optional settings. `None` if no volumes are attached.
+        raw (`dict`):
+            Raw response from the server. Contains more information about the Space
+            runtime like number of replicas, number of cpu, memory size,...
+    """
+
+    stage: SpaceStage
+    hardware: SpaceHardware | None
+    requested_hardware: SpaceHardware | None
+    sleep_time: int | None
+    storage: SpaceStorage | None
+    dev_mode: bool
+    hot_reloading: SpaceHotReloading | None
+    volumes: list[Volume] | None
+    raw: dict
+
+    def __init__(self, data: dict) -> None:
+        self.stage = data["stage"]
+        hardware_dict = data.get("hardware") or {}
+        self.hardware = hardware_dict.get("current")
+        self.requested_hardware = hardware_dict.get("requested")
+        self.sleep_time = data.get("gcTimeout")
+        self.storage = data.get("storage")
+        self.dev_mode = data.get("devMode", False)
+        self.hot_reloading = SpaceHotReloading(raw_hr) if (raw_hr := data.get("hotReloading")) is not None else None
+        raw_volumes = data.get("volumes")
+        self.volumes = [Volume(**v) for v in raw_volumes] if raw_volumes is not None else None
+        self.raw = data
+
+
+@dataclass
+class SpaceSecret:
+    """
+    Contains information about a secret of a Space.
+
+    Secret values are write-only and cannot be read back. Only the key, description,
+    and last update time are returned by the API.
+
+    Args:
+        key (`str`):
+            Secret key. Example: `"GITHUB_API_KEY"`
+        description (`str` or None):
+            Description of the secret. Example: `"Github API key to access the Github API"`.
+        updated_at (`datetime` or None):
+            datetime of the last update of the secret (if the secret has been updated at least once).
+    """
+
+    key: str
+    description: str | None
+    updated_at: datetime | None
+
+    def __init__(self, key: str, values: dict) -> None:
+        self.key = key
+        self.description = values.get("description")
+        updated_at = values.get("updatedAt")
+        self.updated_at = parse_datetime(updated_at) if updated_at is not None else None
+
+
+@dataclass
+class SpaceVariable:
+    """
+    Contains information about the current variables of a Space.
+
+    Args:
+        key (`str`):
+            Variable key. Example: `"MODEL_REPO_ID"`
+        value (`str`):
+            Variable value. Example: `"the_model_repo_id"`.
+        description (`str` or None):
+            Description of the variable. Example: `"Model Repo ID of the implemented model"`.
+        updatedAt (`datetime` or None):
+            datetime of the last update of the variable (if the variable has been updated at least once).
+    """
+
+    key: str
+    value: str
+    description: str | None
+    updated_at: datetime | None
+
+    def __init__(self, key: str, values: dict) -> None:
+        self.key = key
+        self.value = values["value"]
+        self.description = values.get("description")
+        updated_at = values.get("updatedAt")
+        self.updated_at = parse_datetime(updated_at) if updated_at is not None else None
+
+
+@dataclass
+class SpaceSearchResult:
+    """A single result from the Spaces semantic search API.
+
+    Returned by [`HfApi.search_spaces`].
+
+    Attributes:
+        id (`str`):
+            ID of the Space (e.g. `"username/repo-name"`).
+        author (`str`):
+            Author of the Space.
+        title (`str`):
+            Display title of the Space.
+        emoji (`str` or `None`):
+            Emoji icon of the Space.
+        sdk (`str` or `None`):
+            SDK used by the Space (e.g. `"gradio"`, `"docker"`, `"static"`).
+        likes (`int`):
+            Number of likes.
+        private (`bool`):
+            Whether the Space is private.
+        tags (`list[str]` or `None`):
+            List of tags.
+        runtime ([`SpaceRuntime`] or `None`):
+            Runtime information (stage, hardware, etc.).
+        ai_short_description (`str` or `None`):
+            AI-generated short description.
+        ai_category (`str` or `None`):
+            AI-generated category (e.g. `"Image Generation"`).
+        semantic_relevancy_score (`float` or `None`):
+            Semantic relevancy score (0-1) relative to the search query.
+        trending_score (`int` or `None`):
+            Trending score.
+    """
+
+    id: str
+    author: str
+    title: str
+    emoji: str | None
+    sdk: str | None
+    likes: int
+    private: bool
+    tags: list[str] | None
+    runtime: SpaceRuntime | None
+    ai_short_description: str | None
+    ai_category: str | None
+    semantic_relevancy_score: float | None
+    trending_score: int | None
+
+    def __init__(self, data: dict) -> None:
+        runtime = data.get("runtime")
+        self.id = data["id"]
+        self.author = data.get("author", "")
+        self.title = data.get("title", "")
+        self.emoji = data.get("emoji")
+        self.sdk = data.get("sdk")
+        self.likes = data.get("likes", 0)
+        self.private = data.get("private", False)
+        self.tags = data.get("tags")
+        self.runtime = SpaceRuntime(runtime) if runtime else None
+        self.ai_short_description = data.get("ai_short_description")
+        self.ai_category = data.get("ai_category")
+        self.semantic_relevancy_score = data.get("semanticRelevancyScore")
+        self.trending_score = data.get("trendingScore")
+
+
+@dataclass
+class SpaceTemplate:
+    """
+    Contains information about a Space template available on the Hub.
+
+    Returned by [`HfApi.list_space_templates`]. The `repo_id` can be passed as `space_template`
+    to [`HfApi.create_repo`] to seed a new Space from that template.
+
+    Args:
+        name (`str`):
+            Human-friendly name of the template (e.g. `"JupyterLab"`, `"chatbot"`).
+        repo_id (`str`):
+            Repo id of the template Space (e.g. `"SpacesExamples/jupyterlab"`).
+        sdk (`str`):
+            SDK the template is built with (e.g. `"gradio"`, `"docker"`, `"static"`).
+        preferred_private (`bool`):
+            Whether Spaces created from this template are recommended to be private.
+    """
+
+    name: str
+    repo_id: str
+    sdk: str
+    preferred_private: bool
+
+    def __init__(self, data: dict) -> None:
+        self.name = data["name"]
+        self.repo_id = data["repoId"]
+        self.sdk = data["sdk"]
+        self.preferred_private = data["preferredPrivate"]
+
+
+@dataclass
+class ZeroGpuQuota:
+    """
+    Contains information about the ZeroGPU quota of the authenticated user.
+
+    The ZeroGPU quota is consumed each time you use a ZeroGPU Space (from the UI or through its API) and is reset
+    periodically. See https://huggingface.co/docs/hub/spaces-zerogpu for more details.
+
+    Returned by [`HfApi.get_zero_gpu_quota`].
+
+    Args:
+        base (`float`):
+            Total quota, in GPU-seconds.
+        remaining (`float`):
+            Remaining quota, in GPU-seconds.
+        resets_at (`datetime` or `None`):
+            Date at which the quota will be reset. `None` if the quota has not been used yet.
+        overquota_used (`float` or `None`):
+            Overquota (paid) GPU-seconds consumed once the base quota is exhausted. PRO, Team and Enterprise users
+            can purchase credits to go beyond the base quota at https://huggingface.co/settings/billing?add-credits=true.
+    """
+
+    base: float
+    remaining: float
+    resets_at: datetime | None
+    overquota_used: float | None
+
+    def __init__(self, data: dict) -> None:
+        self.base = data["base"]
+        self.remaining = data["current"]
+        self.resets_at = parse_datetime(resets_at) if (resets_at := data.get("resetsAt")) is not None else None
+        self.overquota_used = data.get("overquotaUsed")
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py
new file mode 100644
index 0000000000000000000000000000000000000000..789ebc1c52d7d3e851b2417fe4390f6645d168d2
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tensorboard_logger.py
@@ -0,0 +1,187 @@
+# Copyright 2023 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.
+"""Contains a logger to push training logs to the Hub, using Tensorboard."""
+
+from pathlib import Path
+
+from ._commit_scheduler import CommitScheduler
+from .errors import EntryNotFoundError
+from .repocard import ModelCard
+from .utils import experimental
+
+
+def _load_summary_writer():
+    """Load a SummaryWriter implementation only when an HFSummaryWriter is instantiated."""
+    try:
+        from tensorboardX import SummaryWriter
+    except ImportError:
+        try:
+            from torch.utils.tensorboard import SummaryWriter
+        except ImportError:
+            raise ImportError(
+                "You must have `tensorboard` installed to use `HFSummaryWriter`. Please run `pip install --upgrade"
+                " tensorboardX` first."
+            ) from None
+    return SummaryWriter
+
+
+class HFSummaryWriter:
+    """
+    Wrapper around the tensorboard's `SummaryWriter` to push training logs to the Hub.
+
+    Data is logged locally and then pushed to the Hub asynchronously. Pushing data to the Hub is done in a separate
+    thread to avoid blocking the training script. In particular, if the upload fails for any reason (e.g. a connection
+    issue), the main script will not be interrupted. Data is automatically pushed to the Hub every `commit_every`
+    minutes (default to every 5 minutes).
+
+    > [!WARNING]
+    > `HFSummaryWriter` is experimental. Its API is subject to change in the future without prior notice.
+
+    Args:
+        repo_id (`str`):
+            The id of the repo to which the logs will be pushed.
+        logdir (`str`, *optional*):
+            The directory where the logs will be written. If not specified, a local directory will be created by the
+            underlying `SummaryWriter` object.
+        commit_every (`int` or `float`, *optional*):
+            The frequency (in minutes) at which the logs will be pushed to the Hub. Defaults to 5 minutes.
+        squash_history (`bool`, *optional*):
+            Whether to squash the history of the repo after each commit. Defaults to `False`. Squashing commits is
+            useful to avoid degraded performances on the repo when it grows too large.
+        repo_type (`str`, *optional*):
+            The type of the repo to which the logs will be pushed. Defaults to "model".
+        repo_revision (`str`, *optional*):
+            The revision of the repo to which the logs will be pushed. Defaults to "main".
+        repo_private (`bool`, *optional*):
+            Whether to make the repo private. If `None` (default), the repo will be public unless the organization's default is private. This value is ignored if the repo already exists.
+        path_in_repo (`str`, *optional*):
+            The path to the folder in the repo where the logs will be pushed. Defaults to "tensorboard/".
+        repo_allow_patterns (`list[str]` or `str`, *optional*):
+            A list of patterns to include in the upload. Defaults to `"*.tfevents.*"`. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        repo_ignore_patterns (`list[str]` or `str`, *optional*):
+            A list of patterns to exclude in the upload. Check out the
+            [upload guide](https://huggingface.co/docs/huggingface_hub/guides/upload#upload-a-folder) for more details.
+        token (`str`, *optional*):
+            Authentication token. Will default to the stored token. See https://huggingface.co/settings/token for more
+            details
+        kwargs:
+            Additional keyword arguments passed to `SummaryWriter`.
+
+    Examples:
+    ```diff
+    # Taken from https://pytorch.org/docs/stable/tensorboard.html
+    - from torch.utils.tensorboard import SummaryWriter
+    + from huggingface_hub import HFSummaryWriter
+
+    import numpy as np
+
+    - writer = SummaryWriter()
+    + writer = HFSummaryWriter(repo_id="username/my-trained-model")
+
+    for n_iter in range(100):
+        writer.add_scalar('Loss/train', np.random.random(), n_iter)
+        writer.add_scalar('Loss/test', np.random.random(), n_iter)
+        writer.add_scalar('Accuracy/train', np.random.random(), n_iter)
+        writer.add_scalar('Accuracy/test', np.random.random(), n_iter)
+    ```
+
+    ```py
+    >>> from huggingface_hub import HFSummaryWriter
+
+    # Logs are automatically pushed every 15 minutes (5 by default) + when exiting the context manager
+    >>> with HFSummaryWriter(repo_id="test_hf_logger", commit_every=15) as logger:
+    ...     logger.add_scalar("a", 1)
+    ...     logger.add_scalar("b", 2)
+    ```
+    """
+
+    @experimental
+    def __new__(cls, *args, **kwargs) -> "HFSummaryWriter":
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        repo_id: str,
+        *,
+        logdir: str | None = None,
+        commit_every: int | float = 5,
+        squash_history: bool = False,
+        repo_type: str | None = None,
+        repo_revision: str | None = None,
+        repo_private: bool | None = None,
+        path_in_repo: str | None = "tensorboard",
+        repo_allow_patterns: list[str] | str | None = "*.tfevents.*",
+        repo_ignore_patterns: list[str] | str | None = None,
+        token: str | None = None,
+        **kwargs,
+    ):
+        # Initialize SummaryWriter
+        self._summary_writer = _load_summary_writer()(logdir=logdir, **kwargs)
+        self.logdir = self._summary_writer.logdir
+
+        # Check logdir has been correctly initialized and fail early otherwise. In practice, SummaryWriter takes care of it.
+        if not isinstance(self.logdir, str):
+            raise ValueError(f"`self.logdir` must be a string. Got '{self.logdir}' of type {type(self.logdir)}.")
+
+        # Append logdir name to `path_in_repo`
+        if path_in_repo is None or path_in_repo == "":
+            path_in_repo = Path(self.logdir).name
+        else:
+            path_in_repo = path_in_repo.strip("/") + "/" + Path(self.logdir).name
+
+        # Initialize scheduler
+        self.scheduler = CommitScheduler(
+            folder_path=self.logdir,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=repo_revision,
+            private=repo_private,
+            token=token,
+            allow_patterns=repo_allow_patterns,
+            ignore_patterns=repo_ignore_patterns,
+            every=commit_every,
+            squash_history=squash_history,
+        )
+
+        # Exposing some high-level info at root level
+        self.repo_id = self.scheduler.repo_id
+        self.repo_type = self.scheduler.repo_type
+        self.repo_revision = self.scheduler.revision
+
+        # Add `hf-summary-writer` tag to the model card metadata
+        try:
+            card = ModelCard.load(repo_id_or_path=self.repo_id, repo_type=self.repo_type)
+        except EntryNotFoundError:
+            card = ModelCard("")
+        tags = card.data.get("tags", [])
+        if "hf-summary-writer" not in tags:
+            tags.append("hf-summary-writer")
+            card.data["tags"] = tags
+            card.push_to_hub(repo_id=self.repo_id, repo_type=self.repo_type)
+
+    def __getattr__(self, name: str):
+        """Forward the SummaryWriter API to the lazily-created writer."""
+        return getattr(self._summary_writer, name)
+
+    def __enter__(self) -> "HFSummaryWriter":
+        self._summary_writer.__enter__()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Push to hub in a non-blocking way when exiting the logger's context manager."""
+        self._summary_writer.__exit__(exc_type, exc_val, exc_tb)
+        future = self.scheduler.trigger()
+        future.result()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tree_cache.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tree_cache.py
new file mode 100644
index 0000000000000000000000000000000000000000..783f8a094ad4afa2cb4de34da20b1569ab606149
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_tree_cache.py
@@ -0,0 +1,152 @@
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""On-disk cache for repository tree listings.
+
+A tree listing is the set of files (with their download metadata) contained in a repo at a given commit. Because a
+commit hash is immutable, its tree listing never changes and can be cached forever without any invalidation logic.
+
+The listing is stored as a human-readable JSON file under `<tree_cache_folder>/trees/<commit_hash>.json`. The
+folder depends on the download target: the per-repo `storage_folder` for `cache_dir` downloads, or
+`local_dir/.cache/huggingface/` for `local_dir` downloads (see `tree_cache_folder_for_local_dir`).
+
+```json
+{
+  "format_version": 1,
+  "files": {
+    "config.json": {"size": 519, "blob_id": "<git sha1>"},
+    "model.safetensors": {"size": 1234, "blob_id": "...", "lfs_sha256": "<sha256>", "lfs_size": 1234, "xet_hash": "..."}
+  }
+}
+```
+"""
+
+import json
+import os
+import tempfile
+import threading
+from dataclasses import dataclass
+
+from .utils import logging
+from .utils._paths import as_extended_path
+from .utils._xet import is_valid_xet_hash
+
+
+logger = logging.get_logger(__name__)
+
+TREE_CACHE_FORMAT_VERSION = 1
+
+# In-memory cache of parsed tree listings, keyed by absolute file path.
+_IN_MEMORY_TREE_CACHE: dict[str, "dict[str, TreeCacheEntry]"] = {}
+_IN_MEMORY_TREE_CACHE_LOCK = threading.Lock()
+
+
+@dataclass(frozen=True)
+class TreeCacheEntry:
+    """Raw metadata of a single file in a cached tree listing, mirroring the `/tree` endpoint fields."""
+
+    size: int
+    blob_id: str
+    lfs_sha256: str | None = None
+    lfs_size: int | None = None
+    xet_hash: str | None = None
+
+    def to_json(self) -> dict:
+        info: dict = {"size": self.size, "blob_id": self.blob_id}
+        if self.lfs_sha256 is not None:
+            info["lfs_sha256"] = self.lfs_sha256
+            info["lfs_size"] = self.lfs_size
+        if self.xet_hash is not None:
+            info["xet_hash"] = self.xet_hash
+        return info
+
+    @classmethod
+    def from_json(cls, info: dict) -> "TreeCacheEntry":
+        return cls(
+            size=info["size"],
+            blob_id=info["blob_id"],
+            lfs_sha256=info.get("lfs_sha256"),
+            lfs_size=info.get("lfs_size"),
+            xet_hash=info.get("xet_hash"),
+        )
+
+
+def is_valid_tree_entries(entries: dict[str, TreeCacheEntry]) -> bool:
+    """Return whether all Xet hashes in the tree listing are valid."""
+    return all(entry.xet_hash is None or is_valid_xet_hash(entry.xet_hash) for entry in entries.values())
+
+
+def _tree_cache_path(tree_cache_folder: str, commit_hash: str) -> str:
+    # Both readers and writers go through here, so they agree on the path (and on the in-memory cache key), including
+    # on Windows where a deep `local_dir`/`cache_dir` requires the extended-length form.
+    return as_extended_path(os.path.join(tree_cache_folder, "trees", f"{commit_hash}.json"))
+
+
+def tree_cache_folder_for_local_dir(local_dir: str) -> str:
+    """Folder under which the `trees/` cache lives for a `local_dir` download."""
+    return os.path.join(local_dir, ".cache", "huggingface")
+
+
+def read_tree_cache(tree_cache_folder: str, commit_hash: str) -> dict[str, TreeCacheEntry] | None:
+    """Return the cached tree listing for a commit hash, or `None` if not cached, invalid, or unreadable."""
+    path = _tree_cache_path(tree_cache_folder, commit_hash)
+    with _IN_MEMORY_TREE_CACHE_LOCK:
+        if path in _IN_MEMORY_TREE_CACHE:
+            cached_entries = _IN_MEMORY_TREE_CACHE[path]
+            return cached_entries if is_valid_tree_entries(cached_entries) else None
+    entries = _read_tree_cache_from_disk(path)
+    if entries is None or not is_valid_tree_entries(entries):
+        return None
+    with _IN_MEMORY_TREE_CACHE_LOCK:
+        _IN_MEMORY_TREE_CACHE[path] = entries
+    return entries
+
+
+def _read_tree_cache_from_disk(path: str) -> dict[str, TreeCacheEntry] | None:
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        if data.get("format_version") != TREE_CACHE_FORMAT_VERSION:
+            # Unknown format (e.g. written by a newer version) => ignore and re-fetch.
+            return None
+        return {file_path: TreeCacheEntry.from_json(info) for file_path, info in data["files"].items()}
+    except FileNotFoundError:
+        return None
+    except (OSError, ValueError, KeyError, TypeError) as e:
+        logger.warning(f"Ignoring corrupted tree cache file {path}: {e}")
+        return None
+
+
+def write_tree_cache(tree_cache_folder: str, commit_hash: str, entries: dict[str, TreeCacheEntry]) -> None:
+    """Write a valid tree listing to the cache (ignoring invalid entries and any failures)."""
+    if not is_valid_tree_entries(entries):
+        return
+
+    path = _tree_cache_path(tree_cache_folder, commit_hash)
+    data = {
+        "format_version": TREE_CACHE_FORMAT_VERSION,
+        "files": {file_path: entries[file_path].to_json() for file_path in sorted(entries)},
+    }
+    try:
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        tmp_fd, tmp_path = tempfile.mkstemp(dir=os.path.dirname(path), suffix=".tmp")
+        with os.fdopen(tmp_fd, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=1)
+        os.replace(tmp_path, path)
+    except OSError as e:
+        logger.warning(f"Ignored error while writing tree cache file {path}: {e}")
+        return
+
+    # Seed the in-memory cache so later readers of this commit skip re-reading and re-parsing the file.
+    with _IN_MEMORY_TREE_CACHE_LOCK:
+        _IN_MEMORY_TREE_CACHE[path] = dict(entries)
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_upload_pipeline.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_upload_pipeline.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae1ab9679f6b2f788d65858f86ab924b2fbeeaa2
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_upload_pipeline.py
@@ -0,0 +1,745 @@
+# coding=utf-8
+# Copyright 2026-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Streamed, multi-commit upload of a folder on top of the Xet upload protocol.
+
+How it works:
+
+- The **coordinator** (caller's thread) walks the list of files and asks the Hub, 256 files at a
+  time, what each file is (regular git blob, xet file, ignored). Regular files are accumulated
+  directly; xet files are registered into a `XetSession` upload-commit, which chunks, deduplicates,
+  retries and uploads them in the background while the coordinator keeps going. No Python-side
+  sha256 computation: `hf_xet` computes it during chunking (single read pass over each file).
+- Whenever enough files have accumulated (adaptive batch size), the batch is handed over to the
+  **committer** thread which joins the xet uploads, drops unchanged files, and creates a git
+  commit for the batch. While a batch is being committed, the coordinator is already uploading
+  the next one.
+- Interrupted uploads are resumable by simply re-running the same call: already-committed files
+  are dropped (no-op detection against the remote oid) and already-uploaded chunks are
+  deduplicated by the xet storage backend, transferring ~0 bytes.
+"""
+
+import queue
+import shutil
+import sys
+import threading
+import time
+from typing import TYPE_CHECKING, Any, Callable
+from urllib.parse import quote
+
+from . import constants
+from ._commit_api import (
+    CommitOperationAdd,
+    CommitOperationDelete,
+    _fetch_upload_modes,
+    _send_commit,
+    _warn_on_overwriting_operations,
+)
+from .errors import RepositoryNotFoundError
+from .utils import are_progress_bars_disabled, logging
+from .utils._xet import (
+    XetTokenType,
+    abort_xet_session,
+    get_xet_session,
+    xet_connection_info_refresh_url,
+    xet_headers_without_auth,
+)
+
+
+if TYPE_CHECKING:
+    from .hf_api import CommitInfo, HfApi
+
+logger = logging.get_logger(__name__)
+
+# Number of files sent to the "preupload" endpoint per call (server-side limit).
+PREUPLOAD_BATCH_SIZE = 256
+
+# Files per git commit: adaptive, scaled up after fast commits and down after failures.
+COMMIT_SIZE_SCALE = [20, 50, 75, 100, 125, 200, 250, 400, 600, 1000]
+INITIAL_COMMIT_SIZE_INDEX = 6  # start at 256 files per commit
+TARGET_COMMIT_DURATION = 40.0  # seconds; scale up batch size if commits are faster than this
+MAX_COMMIT_INTERVAL = 5 * 60.0  # seconds; force a commit if the current batch is older than this
+
+# Budget of regular-file content per commit (regular files are base64-encoded in the payload).
+REGULAR_CONTENT_BYTES_BUDGET = 100 * 1024 * 1024
+
+_SENTINEL = object()  # Sentinel value for the batch queue to indicate the end of the upload
+
+# Live display tuning
+_BAR_WIDTH = 20
+_REFRESH_INTERVAL = 0.5  # seconds between redraws on a TTY
+_NON_TTY_LOG_INTERVAL = 30.0  # seconds between summary logs when stderr is not a TTY
+
+
+def _bar(current: float, total: float, width: int = _BAR_WIDTH) -> str:
+    if total <= 0:
+        return "░" * width
+    filled = int(min(current / total, 1.0) * width)
+    return "█" * filled + "░" * (width - filled)
+
+
+def _format_bytes(n: float) -> str:
+    for unit in ("B", "kB", "MB", "GB", "TB"):
+        if abs(n) < 1000:
+            if n < 10:
+                return f"{n:.2f}{unit}"
+            elif n < 100:
+                return f"{n:.1f}{unit}"
+            return f"{n:.0f}{unit}"
+        n /= 1000
+    return f"{n:.1f}PB"
+
+
+class _LiveDisplay:
+    """Live progress display on stderr::
+
+        Preparing   ████████████████████  11,100 / 11,100 ✓
+        Uploading   ██████████████░░░░░░  580 / 603 files  3.8GB · 19.7MB/s
+        Validating  ████████░░░░░░░░░░░░  43%
+        Committing  ██████████████████░░  10,800 / 11,100  14 commits
+
+    The Validating line appears once the v2 shard finalization API starts reporting
+    progress. Shard upload / validation / sync are folded into this single bar so
+    users are not exposed to Xet-internal "shard" jargon (and so there is only one
+    Committing line — the git commit).
+
+    A small renderer thread redraws all lines in-place every ~0.5 s on a TTY
+    (worker threads only update counters under a lock). When stderr is not a TTY,
+    it falls back to a periodic ``logger.info`` summary instead.
+
+    Disabling progress bars (e.g. agent output mode) only turns off the TTY renderer:
+    the non-TTY log summaries are gated by the logger verbosity alone, so consumers
+    tailing stderr during a long upload still see periodic progress.
+    """
+
+    def __init__(self, total_files: int, enabled: bool = True) -> None:
+        self._total = total_files
+        self._tty = enabled and sys.stderr.isatty()
+        self._active = self._tty or logger.isEnabledFor(logging.INFO)
+        self._lock = threading.Lock()
+        self._drawn_lines = 0  # number of lines printed in the last _redraw call
+        self._stop_event = threading.Event()
+        self._thread: threading.Thread | None = None
+
+        # Counters (written by coordinator/committer threads, read by the renderer)
+        self._prepared = 0
+        self._ignored = 0
+        self._xet_total = 0
+        self._xet_done: set[str] = set()  # item names; unique across batches
+        self._committed = 0  # committed or skipped-as-unchanged
+        self._nb_commits = 0
+
+        # Xet transfer bytes, summed across (possibly concurrent) upload-commits
+        self._xet_bytes = 0
+        self._speed_ema = 0.0
+        self._prev_bytes = 0
+        self._prev_time: float | None = None
+
+        # Shard finalization → single Validating bar (v2 API; activated on first event)
+        self._shard_active = False
+        self._shard_val_total = 0
+        self._shard_val_done = 0
+        self._shards_total = 0
+        self._shards_done = 0
+
+    # -- lifecycle (main thread) ------------------------------------------------
+
+    def start(self) -> None:
+        if not self._active:
+            return
+        if self._tty:
+            sys.stderr.write(f"Found {self._total:,} files to upload\n")
+            sys.stderr.flush()
+        else:
+            logger.info(f"Found {self._total:,} files to upload")
+        self._thread = threading.Thread(target=self._render_loop, name="hf-upload-display", daemon=True)
+        self._thread.start()
+
+    def close(self) -> None:
+        if self._thread is not None:
+            self._stop_event.set()
+            self._thread.join()
+        if self._tty:
+            with self._lock:
+                self._redraw()  # final state
+
+    # -- counter updates (coordinator / committer / xet callback threads) --------
+
+    def notify_prepared(self, n: int) -> None:
+        with self._lock:
+            self._prepared += n
+
+    def notify_ignored(self, n: int) -> None:
+        with self._lock:
+            self._ignored += n
+
+    def notify_xet_registered(self, n: int) -> None:
+        with self._lock:
+            self._xet_total += n
+
+    def notify_xet_uploaded(self, names: list[str]) -> None:
+        with self._lock:
+            self._xet_done.update(names)
+
+    def notify_skipped(self, n: int) -> None:
+        with self._lock:
+            self._committed += n
+
+    def notify_commit(self, n_files: int) -> None:
+        with self._lock:
+            self._committed += n_files
+            self._nb_commits += 1
+
+    def new_xet_callback(self) -> "Callable | None":
+        """Progress callback for one ``new_upload_commit``.
+
+        The byte counters in ``group_report`` are cumulative *per upload-commit* and several
+        upload-commits can be in flight at once (one finalizing, one filling), so each commit
+        gets its own closure tracking its own previous value; increments are summed globally.
+        """
+        if not self._active:
+            return None
+        prev_transfer = 0
+        prev_shard_val_done = 0
+        prev_shard_val_total = 0
+        prev_shards_done = 0
+        prev_shards_total = 0
+
+        def callback(group_report: Any, item_reports: Any) -> None:
+            nonlocal prev_transfer
+            nonlocal prev_shard_val_done, prev_shard_val_total
+            nonlocal prev_shards_done, prev_shards_total
+            with self._lock:
+                completed = group_report.total_transfer_bytes_completed
+                self._xet_bytes += max(0, completed - prev_transfer)
+                prev_transfer = completed
+                for item in item_reports.values():
+                    if item.total_bytes > 0 and item.bytes_completed == item.total_bytes:
+                        self._xet_done.add(item.item_name)
+
+                shard = getattr(group_report, "shard", None)
+                if shard is not None and shard.total_shards > 0:
+                    self._shard_active = True
+
+                    v = shard.total_shard_validation_entries_completed
+                    self._shard_val_done += max(0, v - prev_shard_val_done)
+                    prev_shard_val_done = v
+
+                    v = shard.total_shard_validation_entries
+                    self._shard_val_total += max(0, v - prev_shard_val_total)
+                    prev_shard_val_total = v
+
+                    v = shard.total_shards_completed
+                    self._shards_done += max(0, v - prev_shards_done)
+                    prev_shards_done = v
+
+                    v = shard.total_shards
+                    self._shards_total += max(0, v - prev_shards_total)
+                    prev_shards_total = v
+
+        return callback
+
+    # -- rendering (display thread) ----------------------------------------------
+
+    def _render_loop(self) -> None:
+        last_log = 0.0
+        while not self._stop_event.wait(_REFRESH_INTERVAL):
+            with self._lock:
+                self._update_speed()
+                if self._tty:
+                    self._redraw()
+                elif time.monotonic() - last_log >= _NON_TTY_LOG_INTERVAL:
+                    logger.info(self._summary())
+                    last_log = time.monotonic()
+
+    def _update_speed(self) -> None:
+        now = time.monotonic()
+        if self._prev_time is not None and now > self._prev_time:
+            rate = (self._xet_bytes - self._prev_bytes) / (now - self._prev_time)
+            self._speed_ema = rate if self._speed_ema == 0 else 0.3 * rate + 0.7 * self._speed_ema
+        self._prev_time = now
+        self._prev_bytes = self._xet_bytes
+
+    def _redraw(self) -> None:
+        if self._drawn_lines > 0:
+            sys.stderr.write(f"\033[{self._drawn_lines}A")
+        # Validating sits between Uploading and Committing (before the git commit bar).
+        lines = [self._line_preparing(), self._line_uploading()]
+        if self._shard_active:
+            lines.append(self._line_validating())
+        lines.append(self._line_committing())
+        width = shutil.get_terminal_size().columns
+        for line in lines:
+            truncated = line[: width - 4] + "..." if len(line) > width - 1 else line
+            sys.stderr.write(f"\r\033[K{truncated}\n")
+        sys.stderr.flush()
+        self._drawn_lines = len(lines)
+
+    def _line_preparing(self) -> str:
+        done = " ✓" if self._prepared >= self._total else ""
+        return f"  Preparing   {_bar(self._prepared, self._total)}  {self._prepared:,} / {self._total:,}{done}"
+
+    def _line_uploading(self) -> str:
+        if self._xet_total == 0:
+            bar = _bar(1, 1) if self._prepared >= self._total else _bar(0, 1)
+            return f"  Uploading   {bar}  -"
+        n_done = len(self._xet_done)
+        parts = []
+        if self._xet_bytes > 0:
+            parts.append(_format_bytes(self._xet_bytes))
+        if self._speed_ema > 0:
+            parts.append(f"{_format_bytes(self._speed_ema)}/s")
+        extra = f"  {' · '.join(parts)}" if parts else ""
+        done = " ✓" if self._prepared >= self._total and n_done >= self._xet_total else ""
+        return f"  Uploading   {_bar(n_done, self._xet_total)}  {n_done:,} / {self._xet_total:,} files{extra}{done}"
+
+    def _line_validating(self) -> str:
+        # Prefer validation-entry progress (the long phase). Fall back to shard-completion
+        # counts when entries are absent (e.g. V1 synthetic Result with no Validating frames).
+        # Show a percentage — raw entry counts are opaque Xet internals.
+        if self._shard_val_total > 0:
+            done_n, total_n = self._shard_val_done, self._shard_val_total
+        else:
+            done_n, total_n = self._shards_done, self._shards_total
+        pct = min(100, round(100 * done_n / total_n)) if total_n > 0 else 0
+        return f"  Validating  {_bar(done_n, total_n)}  {pct}%"
+
+    def _line_committing(self) -> str:
+        effective = self._total - self._ignored
+        commits_str = f"  {self._nb_commits} commits" if self._nb_commits > 1 else ""
+        done = " ✓" if self._committed >= effective > 0 else ""
+        return (
+            f"  Committing  {_bar(self._committed, effective)}  {self._committed:,} / {effective:,}{commits_str}{done}"
+        )
+
+    def _summary(self) -> str:
+        summary = (
+            f"Uploading... {self._prepared:,}/{self._total:,} files checked, "
+            f"{len(self._xet_done):,}/{self._xet_total:,} uploaded ({_format_bytes(self._xet_bytes)} transferred), "
+            f"{self._committed:,} committed in {self._nb_commits} commit(s)"
+        )
+        if self._shard_active:
+            if self._shard_val_total > 0:
+                pct = min(100, round(100 * self._shard_val_done / self._shard_val_total))
+                summary += f", validating {pct}%"
+            elif self._shards_total > 0:
+                pct = min(100, round(100 * self._shards_done / self._shards_total))
+                summary += f", validating {pct}%"
+        return summary
+
+
+class _CommitPacer:
+    """Adaptive number of files per commit, to stay below server-side commit timeouts."""
+
+    def __init__(self) -> None:
+        self._index = INITIAL_COMMIT_SIZE_INDEX
+
+    @property
+    def target(self) -> int:
+        return COMMIT_SIZE_SCALE[self._index]
+
+    def record_success(self, duration: float, nb_files: int) -> None:
+        if duration < TARGET_COMMIT_DURATION and nb_files >= self.target:
+            self._index = min(self._index + 1, len(COMMIT_SIZE_SCALE) - 1)
+        elif duration > TARGET_COMMIT_DURATION:
+            self._index = max(self._index - 1, 0)
+
+    def record_failure(self) -> None:
+        self._index = max(self._index - 1, 0)
+
+
+class _Batch:
+    """A group of files destined to a single git commit, with their in-flight xet uploads."""
+
+    def __init__(self) -> None:
+        self.ops: list[CommitOperationAdd] = []
+        self.regular_bytes: int = 0
+        self.xet_commit: Any = None  # XetUploadCommit, opened lazily
+        self.handles: list[tuple[CommitOperationAdd, Any]] = []  # (op, XetFileUpload)
+        self.created_at: float = time.monotonic()
+
+
+class _UploadPipeline:
+    def __init__(
+        self,
+        api: "HfApi",
+        *,
+        repo_id: str,
+        repo_type: str,
+        add_operations: list[CommitOperationAdd],
+        delete_operations: list[CommitOperationDelete],
+        commit_message: str,
+        commit_description: str | None,
+        token: str | bool | None,
+        revision: str | None,
+        create_pr: bool,
+        parent_commit: str | None,
+    ) -> None:
+        self.api = api
+        self.repo_id = repo_id
+        self.repo_type = repo_type
+        self.add_operations = add_operations
+        self.delete_operations = delete_operations
+        self.commit_message = commit_message
+        self.commit_description = commit_description
+        self.token = token
+        self.headers = api._build_hf_headers(token=token)
+        self.revision = revision or constants.DEFAULT_REVISION
+        self.create_pr = create_pr
+        self.parent_commit = parent_commit
+
+        # The base revision is used by the coordinator for ALL preupload calls and the xet token
+        # refresh URL, with the `create_pr` flag — exactly like `create_commit` does. It never
+        # changes during the run, even after a PR has been created.
+        self.base_revision_quoted = quote(self.revision, safe="")
+
+        # Committer state (mutated by the committer thread only)
+        self.commit_revision_quoted = self.base_revision_quoted  # switched to the PR ref once created
+        self.pr_url: str | None = None
+        self.pr_revision: str | None = None
+        self.nb_commits = 0
+        self.last_commit_info: "CommitInfo | None" = None
+        self.pacer = _CommitPacer()
+
+        # Pipeline plumbing
+        self.batch_queue: queue.Queue = queue.Queue(maxsize=1)
+        self.errors: list[BaseException] = []
+        self.abort_event = threading.Event()
+        self.display = _LiveDisplay(total_files=len(add_operations), enabled=not are_progress_bars_disabled())
+
+        # All xet uploads share the same token refresh URL. With `create_pr`, the final ref is not
+        # known in advance: `?create_pr=1` makes the server grant a token valid for PR refs.
+        refresh_url = xet_connection_info_refresh_url(
+            token_type=XetTokenType.WRITE,
+            repo_id=repo_id,
+            repo_type=repo_type,
+            revision=self.base_revision_quoted,
+            endpoint=api.endpoint,
+        )
+        if create_pr:
+            refresh_url += "?create_pr=1"
+        self.xet_session = get_xet_session()
+        self.xet_commit_kwargs = {
+            "token_refresh_url": refresh_url,
+            "token_refresh_headers": self.headers,
+            "custom_headers": xet_headers_without_auth(self.headers),
+        }
+
+        # `.gitignore` rules are enforced server-side: forward the local one if it's being uploaded.
+        self.gitignore_content: str | None = None
+        for op in add_operations:
+            if op.path_in_repo == ".gitignore":
+                with op.as_file() as f:
+                    self.gitignore_content = f.read().decode()
+                break
+
+    def run(self) -> "CommitInfo":
+        _warn_on_overwriting_operations([*self.delete_operations, *self.add_operations])
+        committer = threading.Thread(target=self._committer_loop, name="hf-upload-committer", daemon=True)
+        committer.start()
+        self.display.start()
+        try:
+            self._coordinator_loop()
+        except BaseException:
+            self.abort_event.set()
+            abort_xet_session()
+            raise
+        finally:
+            if self.abort_event.is_set():
+                # The committer exits on its own once the queue is drained (see `_committer_loop`).
+                # Bound the wait so a xet call blocked on the (aborted) session can never hang the
+                # shutdown — the committer is a daemon thread.
+                committer.join(timeout=10)
+            else:
+                self.batch_queue.put(_SENTINEL)
+                committer.join()
+            self.display.close()
+            if self.abort_event.is_set() and self.pr_revision is not None:
+                logger.warning(
+                    f"Upload to pull request {self.pr_url} did not complete. To resume into the"
+                    f' same PR, re-run with `revision="{self.pr_revision}"` (without `create_pr=True`). Re-running'
+                    " with `create_pr=True` would open a new pull request."
+                )
+        if self.errors:
+            raise self.errors[0]
+        return self._final_commit_info()
+
+    # ---------------------------------------------------------------- coordinator
+
+    def _coordinator_loop(self) -> None:
+        import hf_xet
+
+        batch = _Batch()
+        for start in range(0, len(self.add_operations), PREUPLOAD_BATCH_SIZE):
+            if self.abort_event.is_set():
+                self._abort_batch(batch)
+                return
+            chunk = self.add_operations[start : start + PREUPLOAD_BATCH_SIZE]
+            try:
+                _fetch_upload_modes(
+                    additions=chunk,
+                    repo_type=self.repo_type,
+                    repo_id=self.repo_id,
+                    headers=self.headers,
+                    revision=self.base_revision_quoted,
+                    endpoint=self.api.endpoint,
+                    create_pr=self.create_pr,
+                    gitignore_content=self.gitignore_content,
+                )
+            except RepositoryNotFoundError as e:
+                from .hf_api import _CREATE_COMMIT_NO_REPO_ERROR_MESSAGE
+
+                e.append_to_message(_CREATE_COMMIT_NO_REPO_ERROR_MESSAGE)
+                raise
+            self.display.notify_prepared(len(chunk))
+            for op in chunk:
+                if op._should_ignore:
+                    logger.debug(f"Skipping upload for '{op.path_in_repo}' (ignored by gitignore rules).")
+                    self.display.notify_ignored(1)
+                    continue
+                if op._upload_mode == "regular":
+                    batch.regular_bytes += op.upload_info.size
+                else:
+                    if batch.xet_commit is None:
+                        batch.xet_commit = self.xet_session.new_upload_commit(
+                            progress_callback=self.display.new_xet_callback(), **self.xet_commit_kwargs
+                        )
+                    # Upload starts immediately in the background. sha256 is computed by hf_xet
+                    # while chunking, unless already known (e.g. resumed operations).
+                    sha_arg = op.upload_info.sha256.hex() if op.upload_info.is_hashed else hf_xet.COMPUTE_SHA256
+                    if isinstance(op.path_or_fileobj, bytes):
+                        handle = batch.xet_commit.start_upload_bytes(
+                            op.path_or_fileobj, sha256=sha_arg, name=op.path_in_repo
+                        )
+                    else:
+                        handle = batch.xet_commit.start_upload_file(str(op.path_or_fileobj), sha256=sha_arg)
+                    batch.handles.append((op, handle))
+                    self.display.notify_xet_registered(1)
+                batch.ops.append(op)
+
+                if (
+                    len(batch.ops) >= self.pacer.target
+                    or batch.regular_bytes >= REGULAR_CONTENT_BYTES_BUDGET
+                    or (time.monotonic() - batch.created_at > MAX_COMMIT_INTERVAL and len(batch.ops) > 0)
+                ):
+                    self._enqueue(batch)
+                    batch = _Batch()
+        self._enqueue(batch)
+
+    def _enqueue(self, batch: _Batch) -> None:
+        if len(batch.ops) == 0 and not (self.nb_commits == 0 and len(self.delete_operations) > 0):
+            return
+        # Blocks if a batch is already waiting: natural backpressure on scanning/uploading.
+        while not self.abort_event.is_set():
+            try:
+                self.batch_queue.put(batch, timeout=1.0)
+                return
+            except queue.Full:
+                continue
+        self._abort_batch(batch)
+
+    def _abort_batch(self, batch: _Batch) -> None:
+        if batch.xet_commit is not None:
+            try:
+                batch.xet_commit.abort()
+            except Exception:
+                pass
+
+    # ---------------------------------------------------------------- committer
+
+    def _committer_loop(self) -> None:
+        while True:
+            try:
+                batch = self.batch_queue.get(timeout=0.5)
+            except queue.Empty:
+                if self.abort_event.is_set():
+                    return  # aborted: exit once the queue is drained, no sentinel needed
+                continue
+            if batch is _SENTINEL:
+                return
+            try:
+                if not self.abort_event.is_set():
+                    self._process_batch(batch)
+                else:
+                    self._abort_batch(batch)
+            except BaseException as e:
+                self._abort_batch(batch)
+                self.errors.append(e)
+                self.abort_event.set()
+
+    def _process_batch(self, batch: _Batch) -> None:
+        # 1. Wait for all xet uploads of this batch and finalize them (atomic xet commit). Files
+        #    can only be referenced by a git commit once their xet upload-commit is finalized.
+        if batch.xet_commit is not None:
+            batch.xet_commit.wait_to_finish()
+            for op, handle in batch.handles:
+                if not op.upload_info.is_hashed:
+                    op.upload_info.sha256 = bytes.fromhex(handle.result().xet_info.sha256)
+                op._is_uploaded = True
+            # Files whose last progress tick was missed are still done at this point.
+            self.display.notify_xet_uploaded(
+                [
+                    str(op.path_or_fileobj) if not isinstance(op.path_or_fileobj, bytes) else op.path_in_repo
+                    for op, _ in batch.handles
+                ]
+            )
+
+        # 2. Drop files that have not changed compared to the remote (prevents empty commits).
+        #    Their chunks were deduplicated anyway (~0 bytes transferred).
+        ops_to_commit = []
+        for op in batch.ops:
+            if op._remote_oid is not None and op._remote_oid == op._local_oid:
+                logger.debug(f"Skipping commit for '{op.path_in_repo}' (file unchanged).")
+                self.display.notify_skipped(1)
+                continue
+            ops_to_commit.append(op)
+
+        # 3. Create the git commit(s). On failure, scale down and split the batch.
+        if len(ops_to_commit) > 0 or (self.nb_commits == 0 and len(self.delete_operations) > 0):
+            self._commit_with_split(ops_to_commit)
+
+    def _commit_with_split(self, ops: list[CommitOperationAdd]) -> None:
+        try:
+            self._do_commit(ops)
+        except Exception as e:
+            self.pacer.record_failure()
+            if len(ops) <= COMMIT_SIZE_SCALE[0]:
+                raise
+            logger.warning(f"Commit of {len(ops)} files failed ({e!r}). Retrying in smaller chunks.")
+            target = self.pacer.target
+            for start in range(0, len(ops), target):
+                self._commit_with_split(ops[start : start + target])
+
+    def _do_commit(self, ops: list[CommitOperationAdd]) -> None:
+        if self.create_pr and self.pr_revision is None:
+            # Create the (draft) pull request explicitly and push every commit to its ref. Committing
+            # with `?create_pr=1` instead would risk opening a second PR if the commit POST is retried
+            # after a lost response. Created lazily so that a fully-unchanged upload opens no PR.
+            # Note: PRs created this way are always opened against the default branch, hence the
+            # `create_pr` + `revision` combination being rejected in `upload_folder`.
+            pr = self.api.create_pull_request(
+                repo_id=self.repo_id,
+                title=self.commit_message,
+                token=self.token,
+                description=self.commit_description,
+                repo_type=self.repo_type,
+            )
+            if pr.git_reference is None:
+                raise ValueError("Server did not return a git reference for the created pull request.")
+            self.pr_url = pr.url
+            self.pr_revision = pr.git_reference
+            self.commit_revision_quoted = quote(pr.git_reference, safe="")
+
+        operations: list[Any] = list(ops)
+        if self.nb_commits == 0:
+            # Deletions and `parent_commit` ride the first commit.
+            operations = list(self.delete_operations) + operations
+
+        commit_message = (
+            self.commit_message if self.nb_commits == 0 else f"{self.commit_message} (part {self.nb_commits + 1})"
+        )
+        t0 = time.monotonic()
+        # Retried with backoff on transient errors: safe because the commit targets an explicit
+        # ref (`?create_pr=1` is never used, see above).
+        self.last_commit_info = _send_commit(
+            operations=operations,
+            files_to_copy={},
+            commit_message=commit_message,
+            commit_description=self.commit_description or "",
+            repo_type=self.repo_type,
+            repo_id=self.repo_id,
+            headers=self.headers,
+            revision=self.commit_revision_quoted,
+            endpoint=self.api.endpoint,
+            parent_commit=self.parent_commit if self.nb_commits == 0 else None,
+            retry_on_error=True,
+        )
+        duration = time.monotonic() - t0
+        self.pacer.record_success(duration, len(ops))
+        self.nb_commits += 1
+
+        for op in ops:
+            op._is_committed = True
+        self.display.notify_commit(len(ops))
+        logger.debug(f"Committed {len(ops)} file(s) in {duration:.1f}s: {self.last_commit_info.commit_url}")
+
+    # ---------------------------------------------------------------- result
+
+    def _final_commit_info(self) -> "CommitInfo":
+        from .hf_api import CommitInfo
+
+        if self.last_commit_info is None:
+            # Nothing was committed (everything unchanged/ignored): mimic `create_commit` and
+            # return info about the latest commit on the target revision.
+            logger.warning("No files have been modified since last commit. Skipping to prevent empty commit.")
+            info = self.api.repo_info(
+                repo_id=self.repo_id, repo_type=self.repo_type, revision=self.revision, token=self.token
+            )
+            url_prefix = self.api.endpoint
+            if self.repo_type != constants.REPO_TYPE_MODEL:
+                url_prefix = f"{url_prefix}/{self.repo_type}s"
+            return CommitInfo(
+                commit_url=f"{url_prefix}/{self.repo_id}/commit/{info.sha}",
+                commit_message=self.commit_message,
+                commit_description=self.commit_description or "",
+                oid=info.sha,  # type: ignore
+                _endpoint=self.api.endpoint,
+            )
+        if self.nb_commits > 1:
+            logger.info(f"Upload completed in {self.nb_commits} commits.")
+        if self.pr_url is not None:
+            # PR upload: attach the PR info (commit responses don't carry it; the PR is created separately).
+            return CommitInfo(
+                commit_url=self.last_commit_info.commit_url,
+                commit_message=self.last_commit_info.commit_message,
+                commit_description=self.last_commit_info.commit_description,
+                oid=self.last_commit_info.oid,
+                pr_url=self.pr_url,
+                _endpoint=self.api.endpoint,
+            )
+        return self.last_commit_info
+
+
+def pipelined_upload(
+    api: "HfApi",
+    *,
+    repo_id: str,
+    repo_type: str,
+    add_operations: list[CommitOperationAdd],
+    delete_operations: list[CommitOperationDelete],
+    commit_message: str,
+    commit_description: str | None = None,
+    token: str | bool | None = None,
+    revision: str | None = None,
+    create_pr: bool = False,
+    parent_commit: str | None = None,
+) -> "CommitInfo":
+    """Upload a prepared list of operations through the streamed multi-commit pipeline.
+
+    Requires `hf_xet` to be installed. See module docstring for the architecture.
+    """
+
+    return _UploadPipeline(
+        api,
+        repo_id=repo_id,
+        repo_type=repo_type,
+        add_operations=add_operations,
+        delete_operations=delete_operations,
+        commit_message=commit_message,
+        commit_description=commit_description,
+        token=token,
+        revision=revision,
+        create_pr=create_pr,
+        parent_commit=parent_commit,
+    ).run()
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py
new file mode 100644
index 0000000000000000000000000000000000000000..976a97a1d30a5105d26f4cb3746be2c9d10d1e4b
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_payload.py
@@ -0,0 +1,136 @@
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains data structures to parse the webhooks payload."""
+
+from typing import Literal
+
+from .utils import is_pydantic_available
+
+
+if is_pydantic_available():
+    from pydantic import BaseModel
+else:
+    # Define a dummy BaseModel to avoid import errors when pydantic is not installed
+    # Import error will be raised when trying to use the class
+
+    class BaseModel:  # type: ignore [no-redef]
+        def __init__(self, *args, **kwargs) -> None:
+            raise ImportError(
+                "You must have `pydantic` installed to use `WebhookPayload`. This is an optional dependency that"
+                " should be installed separately. Please run `pip install --upgrade pydantic` and retry."
+            )
+
+
+# This is an adaptation of the ReportV3 interface implemented in moon-landing. V0, V1 and V2 have been ignored as they
+# are not in used anymore. To keep in sync when format is updated in
+# https://github.com/huggingface/moon-landing/blob/main/server/lib/HFWebhooks.ts (internal link).
+
+
+WebhookEvent_T = Literal[
+    "create",
+    "delete",
+    "move",
+    "update",
+]
+RepoChangeEvent_T = Literal[
+    "add",
+    "move",
+    "remove",
+    "update",
+]
+RepoType_T = Literal[
+    "dataset",
+    "model",
+    "space",
+]
+DiscussionStatus_T = Literal[
+    "closed",
+    "draft",
+    "open",
+    "merged",
+]
+SupportedWebhookVersion = Literal[3]
+
+
+class ObjectId(BaseModel):
+    id: str
+
+
+class WebhookPayloadUrl(BaseModel):
+    web: str
+    api: str | None = None
+
+
+class WebhookPayloadMovedTo(BaseModel):
+    name: str
+    owner: ObjectId
+
+
+class WebhookPayloadWebhook(ObjectId):
+    version: SupportedWebhookVersion
+
+
+class WebhookPayloadEvent(BaseModel):
+    action: WebhookEvent_T
+    scope: str
+
+
+class WebhookPayloadDiscussionChanges(BaseModel):
+    base: str
+    mergeCommitId: str | None = None
+
+
+class WebhookPayloadComment(ObjectId):
+    author: ObjectId
+    hidden: bool
+    content: str | None = None
+    url: WebhookPayloadUrl
+
+
+class WebhookPayloadDiscussion(ObjectId):
+    num: int
+    author: ObjectId
+    url: WebhookPayloadUrl
+    title: str
+    isPullRequest: bool
+    status: DiscussionStatus_T
+    changes: WebhookPayloadDiscussionChanges | None = None
+    pinned: bool | None = None
+
+
+class WebhookPayloadRepo(ObjectId):
+    owner: ObjectId
+    head_sha: str | None = None
+    name: str
+    private: bool
+    subdomain: str | None = None
+    tags: list[str] | None = None
+    type: Literal["dataset", "model", "space"]
+    url: WebhookPayloadUrl
+
+
+class WebhookPayloadUpdatedRef(BaseModel):
+    ref: str
+    oldSha: str | None = None
+    newSha: str | None = None
+
+
+class WebhookPayload(BaseModel):
+    event: WebhookPayloadEvent
+    repo: WebhookPayloadRepo
+    discussion: WebhookPayloadDiscussion | None = None
+    comment: WebhookPayloadComment | None = None
+    webhook: WebhookPayloadWebhook
+    movedTo: WebhookPayloadMovedTo | None = None
+    updatedRefs: list[WebhookPayloadUpdatedRef] | None = None
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b5e493436263efd28964a6c736b98df5e676f37
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/_webhooks_server.py
@@ -0,0 +1,378 @@
+# Copyright 2023-present, the HuggingFace Inc. team.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Contains `WebhooksServer` and `webhook_endpoint` to create a webhook server easily."""
+
+import atexit
+import inspect
+import os
+from collections.abc import Callable
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Optional
+
+from .utils import experimental, is_fastapi_available, is_gradio_available
+
+
+if TYPE_CHECKING:
+    import gradio as gr
+    from fastapi import FastAPI, Request
+    from fastapi.responses import JSONResponse
+
+
+_global_app: Optional["WebhooksServer"] = None  # ty: ignore[invalid-type-form]
+_is_local = os.environ.get("SPACE_ID") is None
+
+
+@experimental
+class WebhooksServer:
+    """
+    The [`WebhooksServer`] class lets you create an instance of a Gradio app that can receive Huggingface webhooks.
+    These webhooks can be registered using the [`~WebhooksServer.add_webhook`] decorator. Webhook endpoints are added to
+    the app as a POST endpoint to the FastAPI router. Once all the webhooks are registered, the `launch` method has to be
+    called to start the app.
+
+    It is recommended to accept [`WebhookPayload`] as the first argument of the webhook function. It is a Pydantic
+    model that contains all the information about the webhook event. The data will be parsed automatically for you.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to set up your
+    WebhooksServer and deploy it on a Space.
+
+    > [!WARNING]
+    > `WebhooksServer` is experimental. Its API is subject to change in the future.
+
+    > [!WARNING]
+    > You must have `gradio` installed to use `WebhooksServer` (`pip install --upgrade gradio`).
+
+    Args:
+        ui (`gradio.Blocks`, optional):
+            A Gradio UI instance to be used as the Space landing page. If `None`, a UI displaying instructions
+            about the configured webhooks is created.
+        webhook_secret (`str`, optional):
+            A secret key to verify incoming webhook requests. You can set this value to any secret you want as long as
+            you also configure it in your [webhooks settings panel](https://huggingface.co/settings/webhooks). You
+            can also set this value as the `WEBHOOK_SECRET` environment variable. If no secret is provided, the
+            webhook endpoints are opened without any security.
+
+    Example:
+
+        ```python
+        import gradio as gr
+        from huggingface_hub import WebhooksServer, WebhookPayload
+
+        with gr.Blocks() as ui:
+            ...
+
+        app = WebhooksServer(ui=ui, webhook_secret="my_secret_key")
+
+        @app.add_webhook("/say_hello")
+        async def hello(payload: WebhookPayload):
+            return {"message": "hello"}
+
+        app.launch()
+        ```
+    """
+
+    def __new__(cls, *args, **kwargs) -> "WebhooksServer":  # ty: ignore[invalid-type-form]
+        if not is_gradio_available():
+            raise ImportError(
+                "You must have `gradio` installed to use `WebhooksServer`. Please run `pip install --upgrade gradio`"
+                " first."
+            )
+        if not is_fastapi_available():
+            raise ImportError(
+                "You must have `fastapi` installed to use `WebhooksServer`. Please run `pip install --upgrade fastapi`"
+                " first."
+            )
+        _load_fastapi()
+        return super().__new__(cls)
+
+    def __init__(
+        self,
+        ui: Optional["gr.Blocks"] = None,
+        webhook_secret: str | None = None,
+    ) -> None:
+        self._ui = ui
+
+        self.webhook_secret = webhook_secret or os.getenv("WEBHOOK_SECRET")
+        self.registered_webhooks: dict[str, Callable] = {}
+        _warn_on_empty_secret(self.webhook_secret)
+
+    def add_webhook(self, path: str | None = None) -> Callable:
+        """
+        Decorator to add a webhook to the [`WebhooksServer`] server.
+
+        Args:
+            path (`str`, optional):
+                The URL path to register the webhook function. If not provided, the function name will be used as the
+                path. In any case, all webhooks are registered under `/webhooks`.
+
+        Raises:
+            ValueError: If the provided path is already registered as a webhook.
+
+        Example:
+            ```python
+            from huggingface_hub import WebhooksServer, WebhookPayload
+
+            app = WebhooksServer()
+
+            @app.add_webhook
+            async def trigger_training(payload: WebhookPayload):
+                if payload.repo.type == "dataset" and payload.event.action == "update":
+                    # Trigger a training job if a dataset is updated
+                    ...
+
+            app.launch()
+        ```
+        """
+        # Usage: directly as decorator. Example: `@app.add_webhook`
+        if callable(path):
+            # If path is a function, it means it was used as a decorator without arguments
+            return self.add_webhook()(path)
+
+        # Usage: provide a path. Example: `@app.add_webhook(...)`
+        @wraps(FastAPI.post)
+        def _inner_post(*args, **kwargs):
+            func = args[0]
+            abs_path = f"/webhooks/{(path or func.__name__).strip('/')}"
+            if abs_path in self.registered_webhooks:
+                raise ValueError(f"Webhook {abs_path} already exists.")
+            self.registered_webhooks[abs_path] = func
+
+        return _inner_post
+
+    def launch(self, prevent_thread_lock: bool = False, **launch_kwargs: Any) -> None:
+        """Launch the Gradio app and register webhooks to the underlying FastAPI server.
+
+        Input parameters are forwarded to Gradio when launching the app.
+        """
+        ui = self._ui or self._get_default_ui()
+
+        # Start Gradio App
+        #   - as non-blocking so that webhooks can be added afterwards
+        #   - as shared if launch locally (to debug webhooks)
+        launch_kwargs.setdefault("share", _is_local)
+        self.fastapi_app, _, _ = ui.launch(prevent_thread_lock=True, **launch_kwargs)
+
+        # Register webhooks to FastAPI app
+        for path, func in self.registered_webhooks.items():
+            # Add secret check if required
+            if self.webhook_secret is not None:
+                func = _wrap_webhook_to_check_secret(func, webhook_secret=self.webhook_secret)
+
+            # Add route to FastAPI app
+            self.fastapi_app.post(path)(func)
+
+        # Print instructions and block main thread
+        space_host = os.environ.get("SPACE_HOST")
+        url = "https://" + space_host if space_host is not None else (ui.share_url or ui.local_url)
+        if url is None:
+            raise ValueError("Cannot find the URL of the app. Please provide a valid `ui` or update `gradio` version.")
+        url = url.strip("/")
+        message = "\nWebhooks are correctly setup and ready to use:"
+        message += "\n" + "\n".join(f"  - POST {url}{webhook}" for webhook in self.registered_webhooks)
+        message += "\nGo to https://huggingface.co/settings/webhooks to setup your webhooks."
+        print(message)
+
+        if not prevent_thread_lock:
+            ui.block_thread()
+
+    def _get_default_ui(self) -> "gr.Blocks":
+        """Default UI if not provided (lists webhooks and provides basic instructions)."""
+        import gradio as gr
+
+        with gr.Blocks() as ui:
+            gr.Markdown("# This is an app to process 🤗 Webhooks")
+            gr.Markdown(
+                "Webhooks are a foundation for MLOps-related features. They allow you to listen for new changes on"
+                " specific repos or to all repos belonging to particular set of users/organizations (not just your"
+                " repos, but any repo). Check out this [guide](https://huggingface.co/docs/hub/webhooks) to get to"
+                " know more about webhooks on the Huggingface Hub."
+            )
+            gr.Markdown(
+                f"{len(self.registered_webhooks)} webhook(s) are registered:"
+                + "\n\n"
+                + "\n ".join(
+                    f"- [{webhook_path}]({_get_webhook_doc_url(webhook.__name__, webhook_path)})"
+                    for webhook_path, webhook in self.registered_webhooks.items()
+                )
+            )
+            gr.Markdown(
+                "Go to https://huggingface.co/settings/webhooks to setup your webhooks."
+                + "\nYou app is running locally. Please look at the logs to check the full URL you need to set."
+                if _is_local
+                else (
+                    "\nThis app is running on a Space. You can find the corresponding URL in the options menu"
+                    " (top-right) > 'Embed the Space'. The URL looks like 'https://{username}-{repo_name}.hf.space'."
+                )
+            )
+        return ui
+
+
+@experimental
+def webhook_endpoint(path: str | None = None) -> Callable:
+    """Decorator to start a [`WebhooksServer`] and register the decorated function as a webhook endpoint.
+
+    This is a helper to get started quickly. If you need more flexibility (custom landing page or webhook secret),
+    you can use [`WebhooksServer`] directly. You can register multiple webhook endpoints (to the same server) by using
+    this decorator multiple times.
+
+    Check out the [webhooks guide](../guides/webhooks_server) for a step-by-step tutorial on how to set up your
+    server and deploy it on a Space.
+
+    > [!WARNING]
+    > `webhook_endpoint` is experimental. Its API is subject to change in the future.
+
+    > [!WARNING]
+    > You must have `gradio` installed to use `webhook_endpoint` (`pip install --upgrade gradio`).
+
+    Args:
+        path (`str`, optional):
+            The URL path to register the webhook function. If not provided, the function name will be used as the path.
+            In any case, all webhooks are registered under `/webhooks`.
+
+    Examples:
+        The default usage is to register a function as a webhook endpoint. The function name will be used as the path.
+        The server will be started automatically at exit (i.e. at the end of the script).
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Server is automatically started at the end of the script.
+        ```
+
+        Advanced usage: register a function as a webhook endpoint and start the server manually. This is useful if you
+        are running it in a notebook.
+
+        ```python
+        from huggingface_hub import webhook_endpoint, WebhookPayload
+
+        @webhook_endpoint
+        async def trigger_training(payload: WebhookPayload):
+            if payload.repo.type == "dataset" and payload.event.action == "update":
+                # Trigger a training job if a dataset is updated
+                ...
+
+        # Start the server manually
+        trigger_training.launch()
+        ```
+    """
+    if callable(path):
+        # If path is a function, it means it was used as a decorator without arguments
+        return webhook_endpoint()(path)
+
+    @wraps(WebhooksServer.add_webhook)
+    def _inner(func: Callable) -> Callable:
+        app = _get_global_app()
+        app.add_webhook(path)(func)
+        if len(app.registered_webhooks) == 1:
+            # Register `app.launch` to run at exit (only once)
+            atexit.register(app.launch)
+
+        @wraps(app.launch)
+        def _launch_now():
+            # Run the app directly (without waiting atexit)
+            atexit.unregister(app.launch)
+            app.launch()
+
+        func.launch = _launch_now  # type: ignore
+        return func
+
+    return _inner
+
+
+def _get_global_app() -> WebhooksServer:  # ty: ignore[invalid-type-form]
+    global _global_app
+    if _global_app is None:
+        _global_app = WebhooksServer()
+    return _global_app
+
+
+def _load_fastapi() -> None:
+    global FastAPI, JSONResponse, Request
+
+    from fastapi import FastAPI, Request
+    from fastapi.responses import JSONResponse
+
+
+def _warn_on_empty_secret(webhook_secret: str | None) -> None:
+    if webhook_secret is None:
+        print("Webhook secret is not defined. This means your webhook endpoints will be open to everyone.")
+        print(
+            "To add a secret, set `WEBHOOK_SECRET` as environment variable or pass it at initialization: "
+            "\n\t`app = WebhooksServer(webhook_secret='my_secret', ...)`"
+        )
+        print(
+            "For more details about webhook secrets, please refer to"
+            " https://huggingface.co/docs/hub/webhooks#webhook-secret."
+        )
+    else:
+        print("Webhook secret is correctly defined.")
+
+
+def _get_webhook_doc_url(webhook_name: str, webhook_path: str) -> str:
+    """Returns the anchor to a given webhook in the docs (experimental)"""
+    return "/docs#/default/" + webhook_name + webhook_path.replace("/", "_") + "_post"
+
+
+def _wrap_webhook_to_check_secret(func: Callable, webhook_secret: str) -> Callable:
+    """Wraps a webhook function to check the webhook secret before calling the function.
+
+    This is a hacky way to add the `request` parameter to the function signature. Since FastAPI based itself on route
+    parameters to inject the values to the function, we need to hack the function signature to retrieve the `Request`
+    object (and hence the headers). A far cleaner solution would be to use a middleware. However, since
+    `fastapi==0.90.1`, a middleware cannot be added once the app has started. And since the FastAPI app is started by
+    Gradio internals (and not by us), we cannot add a middleware.
+
+    This method is called only when a secret has been defined by the user. If a request is sent without the
+    "x-webhook-secret", the function will return a 401 error (unauthorized). If the header is sent but is incorrect,
+    the function will return a 403 error (forbidden).
+
+    Inspired by https://stackoverflow.com/a/33112180.
+    """
+    initial_sig = inspect.signature(func)
+
+    @wraps(func)
+    async def _protected_func(request: Request, **kwargs):
+        request_secret = request.headers.get("x-webhook-secret")
+        if request_secret is None:
+            return JSONResponse({"error": "x-webhook-secret header not set."}, status_code=401)
+        if request_secret != webhook_secret:
+            return JSONResponse({"error": "Invalid webhook secret."}, status_code=403)
+
+        # Inject `request` in kwargs if required
+        if "request" in initial_sig.parameters:
+            kwargs["request"] = request
+
+        # Handle both sync and async routes
+        if inspect.iscoroutinefunction(func):
+            return await func(**kwargs)
+        else:
+            return func(**kwargs)
+
+    # Update signature to include request
+    if "request" not in initial_sig.parameters:
+        _protected_func.__signature__ = initial_sig.replace(  # type: ignore
+            parameters=(
+                inspect.Parameter(name="request", kind=inspect.Parameter.POSITIONAL_OR_KEYWORD, annotation=Request),
+            )
+            + tuple(initial_sig.parameters.values())
+        )
+
+    # Return protected route
+    return _protected_func
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__init__.py b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..15c9257674e1f57ed2437e5725dc11e082e13e7f
--- /dev/null
+++ b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__init__.py
@@ -0,0 +1,14 @@
+# Copyright 2025 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.
+from huggingface_hub.cli._output import out  # noqa: F401
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/__init__.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cd2d3be833463fbffd4c6052287da8f3cbb3692a
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/__init__.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_city_game.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_city_game.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..08ea9e2b774a819acb466321388ef80e6d1ce512
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_city_game.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cli_utils.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cli_utils.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9cdf9e6101968dddc562183bad7524fffb84f194
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cli_utils.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_completion.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_completion.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9c14332e61a7ef2c48d198eedb62ce53207c5b94
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_completion.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cp.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cp.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3ff61a006e94c00e9b6f3f21b38d5d89d020c3f1
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_cp.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_errors.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_errors.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..2367d70940ba2534537dfa100e0e68c6e14127d6
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_errors.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_file_listing.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_file_listing.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..459ed8cef64d31feb094c13a5ca7bad99750e57f
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_file_listing.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_framework.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_framework.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..711fdebb262bd029a84e706c29d23fec2c3ced95
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_framework.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_help_formatter.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_help_formatter.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a168d1e9746fcbe269b5a7265a1b363f50b31fee
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_help_formatter.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_output.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_output.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cf86dfd4b713ff584ec4db0a88333733e281537e
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_output.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_skills.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_skills.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54e3a8460bcca419376ba7914176b7ca4e99b493
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_skills.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_uv_script_header.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_uv_script_header.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c8466b94d062da51e5f041cb86a750264dabcfd
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/_uv_script_header.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/auth.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/auth.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..10b9227abfe285ed01030f2108a0ad3ab8d6ba20
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/auth.cpython-311.pyc differ
diff --git a/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/buckets.cpython-311.pyc b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/buckets.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..853489ee098187be9ecf718ed7840c304c063bba
Binary files /dev/null and b/physworld_p1_20261018/envs/p1/lib/python3.11/site-packages/huggingface_hub/cli/__pycache__/buckets.cpython-311.pyc differ