diff --git a/data/phase2_final.zip b/data/phase2_final.zip new file mode 100644 index 0000000000000000000000000000000000000000..72c8d3d3598ca29443969bfbcb64c627be7d6afe --- /dev/null +++ b/data/phase2_final.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afa498308b45deb1ab78260708d761913f71afab6fd479b6f60b2f6892ab1974 +size 3418573 diff --git a/data/phase3_ckpt_1050000.zip b/data/phase3_ckpt_1050000.zip new file mode 100644 index 0000000000000000000000000000000000000000..6fce735cec1fca62adebccdb8ab687806461c81b --- /dev/null +++ b/data/phase3_ckpt_1050000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5001400b53e3c5c7628047424878e12672d343a6e74a3f9e27630149b4d1c2f3 +size 3418561 diff --git a/data/phase3_ckpt_1100000.zip b/data/phase3_ckpt_1100000.zip new file mode 100644 index 0000000000000000000000000000000000000000..42cb1b30414943e8c7c685d45334b3aa3dac0bb9 --- /dev/null +++ b/data/phase3_ckpt_1100000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b880ccd82ec208405ca2dad4eeaa14d7d3715c6e7adfa731e8d3822fc3d3ce6b +size 3418560 diff --git a/data/phase3_ckpt_1150000.zip b/data/phase3_ckpt_1150000.zip new file mode 100644 index 0000000000000000000000000000000000000000..3db7d65613114604cd832b75a697ee72d91b6748 --- /dev/null +++ b/data/phase3_ckpt_1150000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4d996e0e4d8d296e1b2da51251e4209d69850ef3118285ac54b1d3130ae4a895 +size 3418560 diff --git a/data/phase3_ckpt_1200000.zip b/data/phase3_ckpt_1200000.zip new file mode 100644 index 0000000000000000000000000000000000000000..dbd984770ee882e918ab36f61f494e2e5c9957ae --- /dev/null +++ b/data/phase3_ckpt_1200000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d22eec59610d3789c9450043d85da29a065a09b5b26fa87dd4dbb9fc3524fcdb +size 3418560 diff --git a/data/phase3_ckpt_1250000.zip b/data/phase3_ckpt_1250000.zip new file mode 100644 index 0000000000000000000000000000000000000000..b15ea71e0d84f5ba30b57ace59df5ee7aecd9c24 --- /dev/null +++ b/data/phase3_ckpt_1250000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:5314c609198a1c6df777d21326da66e0928a967c17fe5fa3d1f888a2485c1213 +size 3418560 diff --git a/data/phase3_ckpt_1300000.zip b/data/phase3_ckpt_1300000.zip new file mode 100644 index 0000000000000000000000000000000000000000..e1cc124fa16dfc618ac109b8b33920254bef851d --- /dev/null +++ b/data/phase3_ckpt_1300000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b0155e5f790eddd5594e361377ba1b810661b825b253b474f26123ddbb19e0ad +size 3418561 diff --git a/data/phase3_ckpt_1350000.zip b/data/phase3_ckpt_1350000.zip new file mode 100644 index 0000000000000000000000000000000000000000..8aff29839aac95d8b865e28c95200a9abe0f8c20 --- /dev/null +++ b/data/phase3_ckpt_1350000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f02cdf8448a0a7b19f7d4b95e90677fd976b013cacba0c5a6fb62ac30f7427f6 +size 3418561 diff --git a/data/phase3_ckpt_1400000.zip b/data/phase3_ckpt_1400000.zip new file mode 100644 index 0000000000000000000000000000000000000000..af30ae25c597dcfef555cd338ba78b20ce399d24 --- /dev/null +++ b/data/phase3_ckpt_1400000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:dcf7d4bba9808c5f6e869114b284022f6ab28627199abcca7e62e042d1d48ecb +size 3418561 diff --git a/data/phase3_ckpt_1450000.zip b/data/phase3_ckpt_1450000.zip new file mode 100644 index 0000000000000000000000000000000000000000..f136074ad38a6b91f644bd0d842311a7fc4e9f01 --- /dev/null +++ b/data/phase3_ckpt_1450000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:895cdda788af09d15563a73a2b0568e1e4af6112eac860fc8809da1d4ecfbed8 +size 3418560 diff --git a/data/phase3_ckpt_1500000.zip b/data/phase3_ckpt_1500000.zip new file mode 100644 index 0000000000000000000000000000000000000000..e9dd2ca446aa116e609328a13cb8e7a352ee33de --- /dev/null +++ b/data/phase3_ckpt_1500000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:edd4e345c28a8cb9f2ab3a81165e42b2c9a4793191f053fdbd892b24f21b8528 +size 3418560 diff --git a/data/phase3_ckpt_1550000.zip b/data/phase3_ckpt_1550000.zip new file mode 100644 index 0000000000000000000000000000000000000000..b7413119d4a7d5c1b0fcc6a7f5f3e0584543c1ee --- /dev/null +++ b/data/phase3_ckpt_1550000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d3c6effac4444aedc35f8f331b7e346f7be07bc8288f423bb293c78a6d153091 +size 3418561 diff --git a/data/phase3_ckpt_1600000.zip b/data/phase3_ckpt_1600000.zip new file mode 100644 index 0000000000000000000000000000000000000000..fb56ac7a250cd4670dfd509462976684f48f67b0 --- /dev/null +++ b/data/phase3_ckpt_1600000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:d846ab543cd7ca124c587c686e25a8a81359ff63b1b0171dfe780ab397d66065 +size 3418561 diff --git a/data/phase3_ckpt_1650000.zip b/data/phase3_ckpt_1650000.zip new file mode 100644 index 0000000000000000000000000000000000000000..247cfe28d7f54ce5af8d3abc41ebe73fe93668bb --- /dev/null +++ b/data/phase3_ckpt_1650000.zip @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:be146b2f5134cd99c1ec555985470fe95a7efb219163cef6eb08601a291b97de +size 3418561 diff --git a/phase3_eval_1050000.txt b/phase3_eval_1050000.txt new file mode 100644 index 0000000000000000000000000000000000000000..71385789f077fcd0248134eaeed0e95d669c0375 --- /dev/null +++ b/phase3_eval_1050000.txt @@ -0,0 +1,4 @@ +Stage: static +Step: 1050000 +WinRate: 100.0% +AvgReward: 256.8 diff --git a/phase3_eval_1100000.txt b/phase3_eval_1100000.txt new file mode 100644 index 0000000000000000000000000000000000000000..3395796caddc6f5b610fc06d02647b0ff38fdd38 --- /dev/null +++ b/phase3_eval_1100000.txt @@ -0,0 +1,4 @@ +Stage: random +Step: 1100000 +WinRate: 95.0% +AvgReward: 205.0 diff --git a/phase3_eval_1150000.txt b/phase3_eval_1150000.txt new file mode 100644 index 0000000000000000000000000000000000000000..3887d659d265702d930e63b88b599bdd05f329f1 --- /dev/null +++ b/phase3_eval_1150000.txt @@ -0,0 +1,4 @@ +Stage: simple_bomb +Step: 1150000 +WinRate: 82.0% +AvgReward: 106.5 diff --git a/phase3_eval_1200000.txt b/phase3_eval_1200000.txt new file mode 100644 index 0000000000000000000000000000000000000000..05270aa580eb6ae86da39f2854db95eff84651e2 --- /dev/null +++ b/phase3_eval_1200000.txt @@ -0,0 +1,4 @@ +Stage: evasive +Step: 1200000 +WinRate: 92.0% +AvgReward: 167.4 diff --git a/phase3_eval_1250000.txt b/phase3_eval_1250000.txt new file mode 100644 index 0000000000000000000000000000000000000000..3ea787b40c0f21a5c88adc4b88716d7ca7cef3dd --- /dev/null +++ b/phase3_eval_1250000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1250000 +WinRate: 93.0% +AvgReward: 170.0 diff --git a/phase3_eval_1300000.txt b/phase3_eval_1300000.txt new file mode 100644 index 0000000000000000000000000000000000000000..d6199b339c7cf16f303ac043c2fd7bd9c5aacde0 --- /dev/null +++ b/phase3_eval_1300000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1300000 +WinRate: 91.0% +AvgReward: 157.5 diff --git a/phase3_eval_1350000.txt b/phase3_eval_1350000.txt new file mode 100644 index 0000000000000000000000000000000000000000..7618565b9623faaff5f3efdc9e48d878f66e249a --- /dev/null +++ b/phase3_eval_1350000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1350000 +WinRate: 98.0% +AvgReward: 216.9 diff --git a/phase3_eval_1400000.txt b/phase3_eval_1400000.txt new file mode 100644 index 0000000000000000000000000000000000000000..2041a7cdc20b7617c58cfb5d653f0c95c5ff078c --- /dev/null +++ b/phase3_eval_1400000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1400000 +WinRate: 94.0% +AvgReward: 174.5 diff --git a/phase3_eval_1450000.txt b/phase3_eval_1450000.txt new file mode 100644 index 0000000000000000000000000000000000000000..ca74c265479fb836139dd329a9c82b0a101408fa --- /dev/null +++ b/phase3_eval_1450000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1450000 +WinRate: 93.0% +AvgReward: 205.1 diff --git a/phase3_eval_1500000.txt b/phase3_eval_1500000.txt new file mode 100644 index 0000000000000000000000000000000000000000..6957c062a20b17ac00693b410576dbe70f235776 --- /dev/null +++ b/phase3_eval_1500000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1500000 +WinRate: 92.0% +AvgReward: 205.3 diff --git a/phase3_eval_1550000.txt b/phase3_eval_1550000.txt new file mode 100644 index 0000000000000000000000000000000000000000..3270e86307cbd32c63ead5f67c483c1f299419b1 --- /dev/null +++ b/phase3_eval_1550000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1550000 +WinRate: 92.0% +AvgReward: 172.1 diff --git a/phase3_eval_1600000.txt b/phase3_eval_1600000.txt new file mode 100644 index 0000000000000000000000000000000000000000..ea7938613be2afe5454ec557549a4f733d9a7fd0 --- /dev/null +++ b/phase3_eval_1600000.txt @@ -0,0 +1,4 @@ +Stage: mixed +Step: 1600000 +WinRate: 98.0% +AvgReward: 205.9 diff --git a/til-26-ae-repo/.gitattributes b/til-26-ae-repo/.gitattributes new file mode 100644 index 0000000000000000000000000000000000000000..a6344aac8c09253b3b630fb776ae94478aa0275b --- /dev/null +++ b/til-26-ae-repo/.gitattributes @@ -0,0 +1,35 @@ +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/til-26-ae-repo/README.md b/til-26-ae-repo/README.md new file mode 100644 index 0000000000000000000000000000000000000000..d2670077a467daef178cd0e3ad9849c701fdf526 --- /dev/null +++ b/til-26-ae-repo/README.md @@ -0,0 +1,14 @@ +--- +title: Til 26 Ae +emoji: πŸ”₯ +colorFrom: purple +colorTo: green +sdk: gradio +sdk_version: 6.14.0 +python_version: '3.12' +app_file: app.py +pinned: false +short_description: Autonomous Exploration Challenge +--- + +Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/til-26-ae-repo/ae/Dockerfile b/til-26-ae-repo/ae/Dockerfile new file mode 100644 index 0000000000000000000000000000000000000000..6b7979ff6dffc16256f0c55c39e6daaaff528cab --- /dev/null +++ b/til-26-ae-repo/ae/Dockerfile @@ -0,0 +1,23 @@ +# Dockerfile for building the AE image. + + +# The base image. Using a regular Python base because AE agents don't typically +# require GPU. This will speed up your evaluation. +FROM python:3.11-slim + +# Configures settings for the image. +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 +ENV PIP_ROOT_USER_ACTION=ignore +WORKDIR /workspace + +# Installs your dependencies. +RUN pip install -U pip +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copies your source files. +COPY src . + +# Starts your model server. +CMD uvicorn ae_server:app --port 5005 --host 0.0.0.0 diff --git a/til-26-ae-repo/ae/README.md b/til-26-ae-repo/ae/README.md new file mode 100644 index 0000000000000000000000000000000000000000..9d195733a0d1f43272cc1aaddff4a1524c7656e2 --- /dev/null +++ b/til-26-ae-repo/ae/README.md @@ -0,0 +1,77 @@ +# AE + +Your AE challenge is to direct your agent through the game map while interacting with other agents and completing challenges. + +This Readme provides a brief overview of the interface format; see the Wiki for the full [challenge specifications](https://github.com/til-ai/til-26/wiki/Challenge-specifications). + +## Input + +The input is sent via a POST request to the `/ae` route on port `5005`. It is a JSON object structured as such: + +```JSON +{ + "instances": [ + { + "observation": { + "agent_viewcone": [[[0, ...], ...], ...], + "base_viewcone": [[[0, ...], ...], ...], + "direction": 0, + "location": [0, 0], + "base_location": [0, 0], + "health": [60.0], + "frozen_ticks": 0, + "base_health": [100.0], + "team_resources": [0.0], + "team_bombs": 0, + "step": 0, + "action_mask": [1, 1, 1, 1, 1, 0] + } + } + ] +} +``` + + +| Field | Shape / type | Description | +| --- | --- | --- | +| `agent_viewcone` | `float32 [7 Γ— 5 Γ— 25]` | Viewcone centred on this agent, oriented to its facing direction | +| `base_viewcone` | `float32 [5 Γ— 5 Γ— 25]` | Square view centred on the team base | +| `direction` | `Discrete(4)` | Facing direction (0=RIGHT, 1=DOWN, 2=LEFT, 3=UP) | +| `location` | `uint8 [2]` | Agent (x, y) grid position | +| `base_location` | `uint8 [2]` | Team base (x, y) grid position | +| `health` | `float32 [1]` | Agent current HP | +| `frozen_ticks` | `Discrete(freeze_turns+1)` | Remaining freeze steps (0 = active) | +| `base_health` | `float32 [1]` | Team base current HP | +| `team_resources` | `float32 [1]` | Accumulated resource ratio for this agent's team | +| `team_bombs` | `Discrete(max_team_bombs+1)` | Bomb stockpile for this agent's team | +| `step` | `Discrete(num_iters+1)` | Current step index | +| `action_mask` | `uint8 [6]` | Binary mask β€” 1 = action is legal this step | + +The length of the `instances` array is 1. + +NOTE: Reset as a POST endpoint on your ae_server.py will not be called. You are recommended to check if the current observation step is 0, and if so, reset your system internally. We will NOT be calling /reset to your server, for qualifiers OR finals. + +## Output + +Your route handler function must return a `dict` with this structure: + +```Python +{ + "predictions": [ + { + "action": 0 + } + ] +} +``` + +The action is an integer: + +| Index | Name | Description | +| --- | --- | --- | +| 0 | `FORWARD` | Move one cell in the facing direction | +| 1 | `BACKWARD` | Move one cell opposite to facing direction | +| 2 | `LEFT` | Turn 90Β° counter-clockwise | +| 3 | `RIGHT` | Turn 90Β° clockwise | +| 4 | `STAY` | Do not move | +| 5 | `PLACE_BOMB` | Place a bomb at the current cell (requires `team_bombs > 0`) | diff --git a/til-26-ae-repo/ae/requirements.txt b/til-26-ae-repo/ae/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..7f530def5ca6136ce64955eb4a75b87c5f0a32a5 --- /dev/null +++ b/til-26-ae-repo/ae/requirements.txt @@ -0,0 +1,10 @@ +# Dependencies for AE. +fastapi +uvicorn[standard] + +# Model inference dependencies +sb3-contrib +stable-baselines3 +numpy +torch --index-url https://download.pytorch.org/whl/cpu +huggingface_hub diff --git a/til-26-ae-repo/ae/src/__init__.py b/til-26-ae-repo/ae/src/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c3e3fa634068fdcb7c1e49971b12a669a6ed10ff --- /dev/null +++ b/til-26-ae-repo/ae/src/__init__.py @@ -0,0 +1 @@ +from . import ae_manager, ae_server diff --git a/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-312.pyc b/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df9e08bb1f0ab866de70a38057a9b1d51aa47de4 Binary files /dev/null and b/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-312.pyc differ diff --git a/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-313.pyc b/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..90cc7fb6643468aecfbe39b7ae1a7b5f0b8744b5 Binary files /dev/null and b/til-26-ae-repo/ae/src/__pycache__/ae_manager.cpython-313.pyc differ diff --git a/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-312.pyc b/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6bb9026d0008d96574aed5aff110ad329f742ff3 Binary files /dev/null and b/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-312.pyc differ diff --git a/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-313.pyc b/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-313.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ce71de47e91ebe2966702034b3b0aeb30e6cee25 Binary files /dev/null and b/til-26-ae-repo/ae/src/__pycache__/ae_server.cpython-313.pyc differ diff --git a/til-26-ae-repo/ae/src/ae_manager.py b/til-26-ae-repo/ae/src/ae_manager.py new file mode 100644 index 0000000000000000000000000000000000000000..0e1ec376af48b2c9beab73fed9438e4ae56a6663 --- /dev/null +++ b/til-26-ae-repo/ae/src/ae_manager.py @@ -0,0 +1,105 @@ +"""AE Manager β€” loads trained MaskablePPO and serves inference for Bomberman.""" + +import os +import numpy as np +from sb3_contrib import MaskablePPO +from huggingface_hub import hf_hub_download + +# Model repo where checkpoints are pushed during training +MODEL_REPO = "E-Rong/til-26-ae-agent" + +# Obs flattening constants (must match training script exactly) +_AGENT_VIEWCONE_SIZE = 7 * 5 * 25 # 875 +_BASE_VIEWCONE_SIZE = 5 * 5 * 25 # 625 +_SCALAR_SIZE = 11 # direction + location[2] + base_location[2] + health + frozen_ticks + base_health + team_resources + team_bombs + step +TOTAL_OBS_SIZE = _AGENT_VIEWCONE_SIZE + _BASE_VIEWCONE_SIZE + _SCALAR_SIZE # 1511 + + +def _flatten_obs(obs_dict: dict) -> np.ndarray: + """Flatten a Bomberman observation dict into the (1511,) vector used at train time.""" + return np.concatenate([ + np.array(obs_dict["agent_viewcone"], dtype=np.float32).flatten(), + np.array(obs_dict["base_viewcone"], dtype=np.float32).flatten(), + np.array([obs_dict["direction"]], dtype=np.float32), + np.array(obs_dict["location"], dtype=np.float32).flatten(), + np.array(obs_dict["base_location"], dtype=np.float32).flatten(), + np.array(obs_dict["health"], dtype=np.float32).flatten(), + np.array([obs_dict["frozen_ticks"]], dtype=np.float32), + np.array(obs_dict["base_health"], dtype=np.float32).flatten(), + np.array(obs_dict["team_resources"], dtype=np.float32).flatten(), + np.array([obs_dict["team_bombs"]], dtype=np.float32), + np.array([obs_dict["step"]], dtype=np.float32), + ], dtype=np.float32) + + +class AEManager: + """Loads a trained MaskablePPO model from the Hub and serves actions.""" + + def __init__(self): + self.model = None + self._last_step = -1 + + # Candidates in priority order β€” most trained first + candidates = [ + "phase3_final.zip", + "phase2_final.zip", + "phase1_final.zip", + "ckpt_200000.zip", + "ckpt_150000.zip", + "ckpt_100000.zip", + "ckpt_50000.zip", + ] + + for name in candidates: + try: + path = hf_hub_download( + repo_id=MODEL_REPO, + filename=name, + repo_type="model", + local_dir="/workspace/models", + local_dir_use_symlinks=False, + ) + self.model = MaskablePPO.load(path) + print(f"[AEManager] Loaded model: {name} from {MODEL_REPO}") + break + except Exception as e: + print(f"[AEManager] {name} not available yet ({e}). Trying next...") + + if self.model is None: + print("[AEManager] WARNING: No trained model found β€” will return STAY.") + + def ae(self, observation: dict) -> int: + """Return an action integer given the observation dict. + + Args: + observation: Dict with keys matching the AE input spec. + + Returns: + Integer action in [0, 5]. + """ + # Internal reset tracking (recommended by challenge spec) + step = observation.get("step", 0) + if step == 0 and step != self._last_step: + # New episode started β€” PPO is stateless so nothing to reset, + # but we can log it for debugging. + print(f"[AEManager] New episode detected at step 0") + self._last_step = step + + # Action mask β€” 1 means legal + mask = np.array(observation.get("action_mask", [1] * 6), dtype=bool) + valid = np.where(mask)[0] + + if self.model is None: + # Fallback if model is missing: random valid action + return int(np.random.choice(valid)) if len(valid) > 0 else 4 + + # Flatten observation + obs_vec = _flatten_obs(observation) + + # Predict with masking (deterministic = True for evaluation) + action, _ = self.model.predict( + obs_vec, + action_masks=mask, + deterministic=True, + ) + return int(action) diff --git a/til-26-ae-repo/ae/src/ae_server.py b/til-26-ae-repo/ae/src/ae_server.py new file mode 100644 index 0000000000000000000000000000000000000000..a9312939e3b7aa3c7fe27b96d2016b7ea6667488 --- /dev/null +++ b/til-26-ae-repo/ae/src/ae_server.py @@ -0,0 +1,42 @@ +"""Runs the AE server.""" + +# Unless you want to do something special with the server, you shouldn't need +# to change anything in this file. + + +from ae_manager import AEManager +from fastapi import FastAPI, Request + +app = FastAPI() +manager = AEManager() + + +@app.post("/ae") +async def ae(request: Request) -> dict[str, list[dict[str, int]]]: + """Feeds an observation into the AE model. + + Returns action taken given current observation (int) + """ + + # get observation, feed into model + input_json = await request.json() + + predictions = [] + # each is a dict with one key "observation" and the value as a dictionary observation + for instance in input_json["instances"]: + observation = instance["observation"] + # reset environment on a new round + # You will have to do your own internal counting and reset your own system between rounds! + # if observation["step"] == 0: + # do internal resetting here + predictions.append({"action": manager.ae(observation)}) + return {"predictions": predictions} + + +# ------------------------------ RESET REMOVED ------------------------------ + + +@app.get("/health") +def health() -> dict[str, str]: + """Health check function for your model.""" + return {"message": "health ok"} diff --git a/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-312-pytest-9.0.3.pyc b/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-312-pytest-9.0.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62e6a1f99add618adf29d990c8186dac04117309 Binary files /dev/null and b/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-312-pytest-9.0.3.pyc differ diff --git a/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-313-pytest-9.0.3.pyc b/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-313-pytest-9.0.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..690924cac1f5d0b0c23016d513bd33fa67cb0648 Binary files /dev/null and b/til-26-ae-repo/ae/tests/__pycache__/conftest.cpython-313-pytest-9.0.3.pyc differ diff --git a/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-312-pytest-9.0.3.pyc b/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-312-pytest-9.0.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c4ea325aff15e6ee7d747c770a9ddd475499c292 Binary files /dev/null and b/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-312-pytest-9.0.3.pyc differ diff --git a/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-313-pytest-9.0.3.pyc b/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-313-pytest-9.0.3.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c5d42c70ea3183a85551edcd75a7c8957a9e288d Binary files /dev/null and b/til-26-ae-repo/ae/tests/__pycache__/test_ae_api.cpython-313-pytest-9.0.3.pyc differ diff --git a/til-26-ae-repo/ae/tests/conftest.py b/til-26-ae-repo/ae/tests/conftest.py new file mode 100644 index 0000000000000000000000000000000000000000..011cd1ccbd55058b0eee17f0800e6a0c1958c9d1 --- /dev/null +++ b/til-26-ae-repo/ae/tests/conftest.py @@ -0,0 +1,11 @@ +"""Expose `ae/src` on sys.path so `ae_server` imports match the Docker image layout.""" + +from __future__ import annotations + +import sys +from pathlib import Path + +_ROOT = Path(__file__).resolve().parents[1] +_SRC = _ROOT / "src" +if str(_SRC) not in sys.path: + sys.path.insert(0, str(_SRC)) diff --git a/til-26-ae-repo/ae/tests/test_ae_api.py b/til-26-ae-repo/ae/tests/test_ae_api.py new file mode 100644 index 0000000000000000000000000000000000000000..b5f08536c5d4d2d7f24ea18f4f6a9b98d1f72a61 --- /dev/null +++ b/til-26-ae-repo/ae/tests/test_ae_api.py @@ -0,0 +1,51 @@ +"""In-process HTTP contract tests for the AE FastAPI app (pre-Docker).""" + +from __future__ import annotations + +import pytest +from ae_server import app +from fastapi.testclient import TestClient + + +@pytest.fixture +def client() -> TestClient: + return TestClient(app) + + +def _observation(*, step: int) -> dict: + return { + "viewcone": [[0, 0], [0, 0]], + "direction": 0, + "location": [0, 0], + "scout": 0, + "step": step, + } + + +def test_health_ok(client: TestClient) -> None: + r = client.get("/health") + assert r.status_code == 200 + assert r.json() == {"message": "health ok"} + + +def test_ae_returns_action(client: TestClient) -> None: + payload = {"instances": [{"observation": _observation(step=1)}]} + r = client.post("/ae", json=payload) + assert r.status_code == 200 + body = r.json() + assert "predictions" in body + assert len(body["predictions"]) == 1 + assert body["predictions"][0] == {"action": 0} + + +def test_ae_step_zero_and_reset(client: TestClient) -> None: + r = client.post("/ae", json={"instances": [{"observation": _observation(step=0)}]}) + assert r.status_code == 200 + assert r.json()["predictions"][0]["action"] == 0 + + r_reset = client.post("/reset") + assert r_reset.status_code == 200 + + r2 = client.post("/ae", json={"instances": [{"observation": _observation(step=1)}]}) + assert r2.status_code == 200 + assert isinstance(r2.json()["predictions"][0]["action"], int) diff --git a/til-26-ae-repo/test/test_ae.py b/til-26-ae-repo/test/test_ae.py new file mode 100644 index 0000000000000000000000000000000000000000..4d43546396eb5636c8a36c537d320aa041471e3d --- /dev/null +++ b/til-26-ae-repo/test/test_ae.py @@ -0,0 +1,62 @@ +import json +import os + +import requests +from dotenv import load_dotenv +from til_environment import bomberman_env +from til_environment.config import default_config +from tqdm import tqdm, trange + +load_dotenv() +TEAM_NAME = os.getenv("TEAM_NAME") +TEAM_TRACK = os.getenv("TEAM_TRACK") + +NUM_ROUNDS = 6 +MAX_SCORE = 1000 + + +def main(novice: bool): + config = default_config() + config.env.novice = novice + env = bomberman_env.basic_env(env_wrappers=[], cfg=config) + # be the agent at index 0 + _agent = env.possible_agents[0] + rewards = {agent: 0 for agent in env.possible_agents} + + for i in trange(NUM_ROUNDS): + print("Round", i + 1) + env.reset() + # reset endpoint + _ = requests.post("http://localhost:5005/ae") + + for agent in tqdm(env.agent_iter(), total=1200, leave=False): + observation, reward, termination, truncation, info = env.last() + observation = { + k: v if type(v) in (int, float) else v.tolist() + for k, v in observation.items() + } + + for a in env.agents: + rewards[a] += env.rewards[a] + + if termination or truncation: + action = None + elif agent == _agent: + response = requests.post( + "http://localhost:5005/ae", + data=json.dumps({"instances": [{"observation": observation}]}), + ) + predictions = response.json()["predictions"] + + action = int(predictions[0]["action"]) + else: + # take random action from other agents + action = env.action_space(agent).sample() + env.step(action) + env.close() + print(f"total rewards: {rewards[_agent]}") + print(f"score: {rewards[_agent] / NUM_ROUNDS / MAX_SCORE}") + + +if __name__ == "__main__": + main(TEAM_TRACK == "novice") diff --git a/til-26-ae-repo/til-26-ae/.gitignore b/til-26-ae-repo/til-26-ae/.gitignore new file mode 100644 index 0000000000000000000000000000000000000000..9789e03ac4e28235adbc427907d1192f921268ac --- /dev/null +++ b/til-26-ae-repo/til-26-ae/.gitignore @@ -0,0 +1,186 @@ +**/.DS_Store +.vscode + +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/latest/usage/project/#working-with-version-control +.pdm.toml +.pdm-python +.pdm-build/ + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + + +# remove other folders +til_environment/tests +til_environment/logs +noise.ipynb +multiview.py +TODOs.md +OPEN_QUESTIONS.md \ No newline at end of file diff --git a/til-26-ae-repo/til-26-ae/.python-version b/til-26-ae-repo/til-26-ae/.python-version new file mode 100644 index 0000000000000000000000000000000000000000..c8cfe3959183f8e9a50f83f54cd723f2dc9c252d --- /dev/null +++ b/til-26-ae-repo/til-26-ae/.python-version @@ -0,0 +1 @@ +3.10 diff --git a/til-26-ae-repo/til-26-ae/AE-with-til_environment.md b/til-26-ae-repo/til-26-ae/AE-with-til_environment.md new file mode 100644 index 0000000000000000000000000000000000000000..856ae85985eafee69f4cffe0f651a61c7f7dfe20 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/AE-with-til_environment.md @@ -0,0 +1,270 @@ +# Using the `til_environment` package + +This page introduces the basics of using the `til_environment` package to run your AE models. + +**Contents** +1. [Using the `til_environment` package](#using-the-til_environment-package) + 1. [Setup](#setup) + 2. [Usage \& Running the environment](#usage--running-the-environment) + 1. [Observation Space](#observation-space) + 2. [Action space](#action-space) + 3. [Configuration](#configuration) + 1. [Key config sections](#key-config-sections) + 2. [Reward shaping](#reward-shaping) + 4. [Use during training](#use-during-training) + 1. [Writing an environment wrapper](#writing-an-environment-wrapper) + 5. [Package structure](#package-structure) + 1. [Key concepts](#key-concepts) + +--- + +## Setup + +**Python 3.10 is required.** + +Clone the `til-26-ae` repo, then create and activate a virtual environment: + +```bash +python3.10 -m venv .venv +source .venv/bin/activate # Linux / macOS +# .venv\Scripts\activate # Windows +pip install -r requirements.txt +``` + +Or, if you prefer [`uv`](https://docs.astral.sh/uv/): + +```bash +uv sync # creates .venv and installs all dependencies automatically. goated +``` + +--- + +## Usage & Running the environment + +You can import the raw environment as such: + +```python +from til_environment.bomberman_env import Bomberman +``` + +This environment follows the [PettingZoo](https://pettingzoo.farama.org/) AEC (Agent-Environment-Cycle) API. Each call to `env.step()` logs an agent's action; a full round executes after the last agent in the cycle submits its action. As such the overall running loop is functionally identical to that of PettingZoo: + + +```python +from til_environment.bomberman_env import Bomberman + +env = Bomberman() + +env.reset(seed=42) + +for agent in env.agent_iter(): + observation, reward, termination, truncation, info = env.last() + + if termination or truncation: + action = None + else: + # Insert your policy here. or dont. like why dont you throw random at it :) + action = env.action_space(agent).sample() + + env.step(action) + +env.close() +``` + +> **Note:** Termination should never fire off. In this game, your agents have been (unfortunately) cursed with immortality. Recall agents only freeze after reaching 0 health, then respawn where they died. Enjoy playing the full 200 iterations! + +### Observation Space + +We've significantly expanded the observation space from last year. This time, we give a series of binary channels (with significant sparsity, i.e many 0s, few 1s, per channel). For a full description of what each channel represents, see [observation.py](til-26-ae/til_environment/observation.py). + +| Key | Shape / type | Description | +| ---------------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------- | +| `agent_viewcone` | `float32 [7 Γ— 5 Γ— 25]` | Viewcone centred on this agent (widths of 4 ahead, 2 behind, 2 to the side, agent at the center inclusive) | +| `base_viewcone` | `float32 [S Γ— S Γ— 25]` | Square view centred on this agent's base (S = 2Γ—vision_radius+1) | +| `direction` | `Discrete(4)` | Agent's facing direction (0=RIGHT, 1=DOWN, 2=LEFT, 3=UP) | +| `location` | `uint8 [2]` | Agent's (x, y) grid position | +| `base_location` | `uint8 [2]` | Team base (x, y) grid position | +| `health` | `float32 [1]` | Agent current HP | +| `frozen_ticks` | `Discrete(freeze_turns+1)` | Remaining freeze steps (0 = active) | +| `base_health` | `float32 [1]` | Team base current HP | +| `team_resources` | `float32 [1]` | Accumulated resource ratio for this agent's team | +| `team_bombs` | `Discrete(max_team_bombs+1)` | Bomb stockpile for this agent's team | +| `step` | `Discrete(num_iters+1)` | Current step index | +| `action_mask` | `uint8 [6]` | Binary mask β€” 1 = action is legal for this agent this step | + +### Action space + +Each agent has 6 discrete actions: + +| Index | Name | Description | +| ----- | ------------ | -------------------------------------------------------------------- | +| 0 | `FORWARD` | Move one cell in the direction the agent is facing | +| 1 | `BACKWARD` | Move one cell opposite to facing direction | +| 2 | `LEFT` | Turn 90Β° counter-clockwise | +| 3 | `RIGHT` | Turn 90Β° clockwise | +| 4 | `STAY` | Do not move | +| 5 | `PLACE_BOMB` | Place a bomb at the agent's current cell (requires `team_bombs > 0`) | + +--- + +## Configuration + +The default config may be obtained via: + +```python +from til_environment.config import default_config +cfg = default_config() +``` + +All tunable environment parameters live in a single OmegaConf config tree. During evaluation for qualifiers, we will use this default configuration: However, you are free to modify it for your training purposes. You can simply modify the YAML file, or do it code-wise as follows: + +```python +from til_environment.config import default_config +from omegaconf import OmegaConf + +cfg = default_config() +# override specific values +cfg = OmegaConf.merge(cfg, {"env": {"grid_size": 10, "num_teams": 2}}) +# but like why. i love writing more config files +``` + +The environment is highly configurable, if you want to explore any ideas, create your own custom reward hooks/events or mutate existing ones, heck even change the environment fundementally for your model training / DP development. Who am I to stop you from trying lots of things out! Not me, probably the time you have. Anyways this ae is quite sandboxable, as long as you acknowledge the default config is what the evaluatons / qualifiers / finals will run. + +### Key config sections + +**`env`** + +| Key | Default | Description | +| -------------------- | ------- | ----------------------------------------------------- | +| `grid_size` | 16 | Grid side length | +| `num_teams` | 6 | Number of competing teams (one agent + one base each) | +| `num_iters` | 200 | Maximum steps before truncation | +| `novice` | `false` | If `true`, fixes the map layout (same every episode) | +| `render_mode` | `null` | `"human"`, `"rgb_array"`, or `null` | +| `tile_respawn_steps` | 40 | * Max Steps before a collected tile reappears. Note this is randomly generated across the board based on perlin noise! Read the code / til-26-ae README for more info | + +**`entities.agent`** + +| Key | Default | Description | +| ----------------------- | ------- | ---------------------------------------------- | +| `health` / `max_health` | 60 | Agent HP | +| `freeze_turns` | 3 | Iterations the agent is frozen after reaching 0 HP | + +**`entities.bomb`** + +| Key | Default | Description | +| -------------- | ------- | ----------------------------- | +| `attack` | 20.0 | Damage per blast cell | +| `blast_radius` | 2 | Radius of explosion | +| `timer` | 4 | Steps until detonation | + +**`resources`** + +| Key | Default | Description | +| -------------------- | ------- | -------------------------------------------------------------------- | +| `bomb_cost` | 1.5 | Resource ratio required to convert into one bomb | +| `base_resource_rate` | 0.1 | Resources added to every team's pool per step (fixed, unconditional) | +| `starting_bombs` | 3 | Bombs each team starts with | + +### Reward shaping + +All reward values are in the config under `rewards`. As you may notice, several are left as 0: We do not penalize these actions, but leave them as open options for reward shaping (that is within your own training pipeline, modifying them in hopes of attaining different behaviour). + + +| Key | Default | Credited to | Description | +| --------------------- | -------------------------- | ----------------------------- | --------------------------------------------------------------------------------------------- | +| `agent_collide_wall` | 0 | Agent | Agent attempts to move into a wall | +| `agent_collide_agent` | 0 | Agent | Agent attempts to move into another agent | +| `collect_mission` | 5.0 | Agent | Agent steps onto a mission tile | +| `collect_recon` | 1.0 | Agent | Agent steps onto a recon tile | +| `collect_resource` | 2.0 | Agent | Agent steps onto a resource tile | +| `attack_damage` | 1.0Γ— damage dealt (20 pts) | Attacker (-1.0Γ— for Defender) | Bomb damages an agent or base; defender receives the equal-and-opposite penalty automatically | +| `attack_kill` | 15.0 | Attacker (flat) | Bomb reduces an agent to 0 HP | +| `destroy_wall` | 0 | Attacker | Bomb destroys a destructible wall | +| `destroy_enemy_base` | 50.0 | Attacker | Bomb destroys an enemy base | +| `own_base_destroyed` | -50.0 | Defending agent | This agent's base is destroyed | +| `step_penalty` | 0 | Agent | Applied every step | +| `stationary_penalty` | 0 | Agent | Agent chose `STAY` | +| `invalid_action` | 0 | Agent | Agent submitted a masked action | + +> **Defenders are penalised automatically.** You do not need a separate config entry. For every `attack_damage` event, the damaged entity's controlling agent receives `-attack_damage Γ— damage_dealt` in the same step. + +--- + +## Use during training + +### Writing an environment wrapper + +Custom wrappers inherit from `BaseWrapper` in PettingZoo. You may want to write custom wrappers to modify the way observations are returned. A basic form of wrapping can be observed in the [basic_env function](til-26-ae/til_environment/bomberman_env.py) + +```python +import functools +from pettingzoo.utils.env import ActionType, AECEnv, AgentID, ObsType +from pettingzoo.utils.wrappers.base import BaseWrapper + +class CustomWrapper(BaseWrapper[AgentID, ObsType, ActionType]): + def __init__(self, env: AECEnv[AgentID, ObsType, ActionType]): + super().__init__(env) + + def reset(self, seed=None, options=None): + super().reset(seed, options) + + def step(self, action: ActionType): + super().step(action) + + def observe(self, agent: AgentID) -> ObsType | None: + obs = super().observe(agent) + # modify obs here + return obs + + @functools.lru_cache(maxsize=None) + def observation_space(self, agent): + return super().observation_space(agent) +``` +Then simply wrap it around by passing the environment inside it. A basic example with some existing wrappers can be found at + +For more wrappers see [PettingZoo Wrappers](https://pettingzoo.farama.org/api/wrappers/pz_wrappers/) and [SuperSuit](https://github.com/Farama-Foundation/SuperSuit). + +--- + +## Package structure + +``` +til_environment/ +β”œβ”€β”€ bomberman_env.py # Top-level PettingZoo AECEnv; basic_env() factory lives here +β”œβ”€β”€ dynamics.py # All game logic: phases, rewards, registry access +β”œβ”€β”€ arena.py # Maze generation (structural + destructible walls, tile placement) +β”œβ”€β”€ config.py # OmegaConf-based config tree; load_config() / default_config() +β”œβ”€β”€ observation.py # Build per-agent viewcone tensors; ViewChannel enum (25 channels) +β”œβ”€β”€ actions.py # ActionV2 enum, ActionMask (legal-move computation) +β”œβ”€β”€ types.py # Direction, Tile enums and shared type aliases +β”œβ”€β”€ renderer.py # Pygame renderer; HUD, replay recording +β”œβ”€β”€ flatten_dict.py # FlattenDictWrapper β€” flattens obs dict to 1-D array +β”œβ”€β”€ helpers.py # Miscellaneous utilities +β”œβ”€β”€ play.py # Interactive harness: launch with `uv run python -m til_environment.play` +β”‚ +β”œβ”€β”€ entities/ +β”‚ β”œβ”€β”€ base.py # Entity base class (entity_id, team, position, alive) +β”‚ β”œβ”€β”€ dynamic.py # Agent, Base, Bomb classes +β”‚ β”œβ”€β”€ static.py # Mission, Recon, Resource, DestructibleWall, AttackIntent +β”‚ β”œβ”€β”€ protocols.py # Structural interfaces: Attacker, Defender, Vision, Item, Timed, ExternalSideEffect +β”‚ β”œβ”€β”€ geometry.py # Blast/vision geometry helpers (RadiusAttack, SquareVision) +β”‚ └── registry.py # EntityRegistry β€” indexed container for all live entities +β”‚ +β”œβ”€β”€ events/ + β”œβ”€β”€ base.py # EmitRule dataclass + wrap_multi() β€” hooks entity methods to reward events + └── rewards.py # Rewards accumulator (step + episode); award() method + +``` + +### Key concepts + +**Agents and teams.** There is exactly one agent per team. Agent IDs are `"agent_0"`, `"agent_1"`, … `"agent_{N-1}"`. Each team also has one base. + +**Death and respawn.** When an agent's HP reaches 0 it enters a *frozen* state for 3 steps β€” it stays on the grid but its entire action mask is zeroed. After the freeze it respawns at the same tile at full HP. Agents are never removed from the game; only step truncation ends an episode. + +**Resource economy.** Each team has a shared resource pool (`team_resources`) and bomb stockpile (`team_bombs`). Resources accumulate passively every step at a fixed rate (`0.1`), and are also collected by stepping on resource tiles (`0.5`). Whenever `team_resources β‰₯ 1.5` the surplus auto-converts into bombs. + +**Bombs.** A placed bomb counts down for `timer` steps then detonates in a cross-shaped blast of square radius `2` (so 2 + 1 + 2, where 1 is the center where the bomb is place). The blast damages agents, bases, and destroys destructible walls in range. Indestructible walls block the blast. + +**Observation channels.** The viewcone tensor has 25 channels encoding visibility, wall edges (structural and destructible, per direction), tile types, ally/enemy entities, bomb presence and timers, and HP levels. Once more, see [`observation.py`](til-26-ae/til_environment/observation.py) (`ViewChannel` enum) for the full list. diff --git a/til-26-ae-repo/til-26-ae/LICENSE b/til-26-ae-repo/til-26-ae/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..aff5ecc28643df4574eb6ad28eecf4cb7e84a432 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 BrainHack TIL-AI + +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/til-26-ae-repo/til-26-ae/README.md b/til-26-ae-repo/til-26-ae/README.md new file mode 100644 index 0000000000000000000000000000000000000000..abd6b4b96caca4d104d2e0baf85316b4a2e83aa4 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/README.md @@ -0,0 +1,175 @@ +# TIL Bomberman β€” Environment + +## Quick Start + +`play.py` controls: `W/A/S/D` or arrow keys to move, `B/F` to place a bomb, `SPACE` to stay, `T` to toggle the respawn-timer overlay, `R` to reset, `Q`/`ESC` to quit. + +--- + +## Overview + +A two-team [PettingZoo](https://pettingzoo.farama.org/) AEC environment built around bomb placement, base defence, and resource management. Each team controls one agent and one stationary base. Agents explore a maze-like arena, collect resource tokens to fund bombs, and destroy the opposing base. Agents are never removed from the game β€” instead, taking lethal damage freezes them in place for a configurable number of ticks before they respawn at full health on the same tile. + +--- + +## Overall Structure + +``` +til_environment/ +β”œβ”€β”€ bomberman_env.py β€” PettingZoo AECEnv wrapper (public API) +β”œβ”€β”€ dynamics.py β€” all mutable game state and phase logic +β”œβ”€β”€ arena.py β€” maze generation, tile placement, spawn assignment +β”œβ”€β”€ observation.py β€” multi-channel viewcone builders +β”œβ”€β”€ actions.py β€” Action enum, ActionMask builder +β”œβ”€β”€ entities/ +β”‚ β”œβ”€β”€ dynamic.py β€” Agent, Base, Bomb (mutable entities) +β”‚ β”œβ”€β”€ static.py β€” Mission, Recon, Resource (collectible entities) +β”‚ β”œβ”€β”€ protocols.py β€” structural trait protocols (Defender, Attacker, …) +β”‚ β”œβ”€β”€ geometry.py β€” RadiusAttack blast-cell computation +β”‚ └── registry.py β€” EntityRegistry (typed, indexed entity container) +β”œβ”€β”€ renderer.py β€” pygame rendering; never mutates game state +β”œβ”€β”€ config.py β€” OmegaConf dataclass config hierarchy +β”œβ”€β”€ bomberman_config.yaml β€” default configuration +β”œβ”€β”€ helpers.py β€” shared grid utilities +└── types.py β€” Direction, Tile, Wall enums +``` + +**`bomberman_env.py`** is the entry point for external code. It subclasses `AECEnv`, delegates all logic to `Dynamics`, and exposes the standard `reset / step / observe / render` contract. `basic_env()` and `parallel_basic_env()` are convenience factory functions that wrap the raw env with `FlattenDictWrapper` and `frame_stack_v2`. + +**`dynamics.py`** owns the mutable world state: agent positions and health, team resource and bomb counts, bomb timers, tile respawn queues, and the per-round phase pipeline. It composes `ArenaGenerator`, `ArenaState`, `EntityRegistry`, `ActionMask`, and the `Rewards` system. + +**`arena.py`** generates the maze (Recursive Backtracking via `mazelib`), marks a fraction of walls as destructible, scatters mission/recon/resource tiles with rotational symmetry across teams, and assigns agent/base starting positions. The wall layout is cached between episodes if the seed does not change. A Perlin-noise + centre-gradient respawn map is generated each episode, giving shorter respawn delays near the map centre. + +**`entities/`** contains the entity hierarchy. All entities share a common `Entity` base (unique ID, position, team). Behaviour is declared via structural protocols (`Defender`, `Attacker`, `Vision`, `Item`, `Timed`) rather than deep inheritance, so `Dynamics` can dispatch on traits without checking concrete types. `EntityRegistry` is an indexed `dict[str, Entity]` with typed accessors (`agents(team)`, `bases(team)`, `bombs()`, etc.). + +**`observation.py`** builds the multi-channel float32 viewcone tensors that agents receive. Line-of-sight is computed with a vectorised supercover algorithm (numpy batch array indexing; precomputed per viewcone shape via `lru_cache`). + +**`renderer.py`** is a stateless pygame drawer. In `"human"` mode it draws to a window; in `"rgb_array"` mode it returns a numpy array. It never reads or writes game state β€” it only reads the `ArenaState`, `EntityRegistry`, and the current `observations` dict passed to it. + +**`config.py`** defines the full config hierarchy as OmegaConf dataclasses. Every tuneable parameter lives here; no scattered constants anywhere else. + +--- + +## Action Space + +Each agent has a flat `Discrete(6)` action space. Bases do not act. + +| Value | Name | Effect | +|-------|-------------|------------------------------------------------------| +| 0 | FORWARD | Move one tile in the agent's current facing direction | +| 1 | BACKWARD | Move one tile opposite to facing | +| 2 | LEFT | Turn left (rotate facing 90Β°), no movement | +| 3 | RIGHT | Turn right (rotate facing 90Β°), no movement | +| 4 | STAY | No action | +| 5 | PLACE_BOMB | Place a bomb on the agent's current tile | + +An **action mask** (shape `(6,)`, `uint8`) is included in every observation. Illegal actions are replaced with `STAY` and penalised. Movement is masked when a wall blocks the path (structural or destructible). `PLACE_BOMB` is masked when the team has no bombs available or the agent is frozen. + +--- + +## Observation Space + +Each agent receives a `Dict` observation: + +| Key | Space | Description | +|------------------|-------------------------------------------|--------------------------------------------------| +| `agent_viewcone` | `Box(0,1, (H,W,25), float32)` | Multi-channel viewcone centred on the agent | +| `base_viewcone` | `Box(0,1, (B,B,25), float32)` | Square view centred on the team base | +| `direction` | `Discrete(4)` | Agent's current facing direction | +| `location` | `Box(0,G, (2,), uint8)` | Agent grid position | +| `base_location` | `Box(0,G, (2,), uint8)` | Team base grid position | +| `health` | `Box(0, max_health, (1,), float32)` | Agent HP | +| `frozen_ticks` | `Discrete(freeze_turns+1)` | Ticks remaining until respawn (0 = active) | +| `base_health` | `Box(0, max_health, (1,), float32)` | Team base HP | +| `team_resources` | `Box(0, max_resources, (1,), float32)` | Shared resource pool (bombs cost 1.0 unit each) | +| `team_bombs` | `Discrete(max_bombs+1)` | Bombs currently available to the team | +| `step` | `Discrete(num_iters+1)` | Current step index | +| `action_mask` | `Box(0,1, (6,), uint8)` | Legal actions this step | + +### Viewcone channels (25 total) + +The viewcone is oriented relative to the agent's facing direction. Channel 0 is a line-of-sight flag; channels 1–4 encode wall edges; channels 5–12 encode tile types and entity presence; channels 13–16 flag destructible wall edges; channels 17–24 encode bomb state and entity health ratios. Index by `ViewChannel.*` enum rather than raw integers. + +--- + +## Game Loop and Phases + +The environment follows the PettingZoo AEC protocol: agents act one at a time. Once all agents have submitted an action the round executes in a fixed phase order: + +1. **Validate** β€” illegal actions are replaced with `STAY`; `invalid_action` penalty awarded +2. **Place bombs** β€” `PLACE_BOMB` actions spawn bombs; `team_bombs[team]` decremented +3. **Movement** β€” agents move or turn; collectibles are picked up inline +4. **Detonation** β€” expired bomb timers produce `AttackIntent` lists +5. **Damage** β€” intents applied to defenders; agents at 0 HP enter frozen state +6. **Upkeep** β€” bomb timers tick; resource pools accrue; auto-convert resources β†’ bombs; frozen agents tick down and respawn + +Termination fires when a team's base is destroyed. Truncation fires at `num_iters` steps. Frozen (dead) agents alone do **not** trigger termination. + +--- + +## Resource and Bomb Economy + +Each team maintains a floating-point resource pool (`team_resources`) and an integer bomb count (`team_bombs`). Resources accumulate every tick at `base_resource_rate` as long as the team's base is alive. Picking up a resource tile adds a fixed amount to the pool. When the pool reaches `bomb_cost` (default 1.5), it is decremented and `team_bombs` incremented. Bombs start the episode at `starting_bombs` (default 3). + +--- + +## Configuration + +All parameters live in `bomberman_config.yaml` (loaded into an OmegaConf `BombermanConfig`). Key sections: + +```yaml +env: + grid_size: 16 + num_teams: 2 + num_iters: 200 +dynamics: + vision: + left: 2 + right: 2 + ahead: 4 + behind: 1 +entities: + agent: + max_health: 100.0 + freeze_turns: 3 + base: + max_health: 200.0 + bomb: + timer: 5 + blast_radius: 2 +resources: + bomb_cost: 1.5 + base_resource_rate: 0.1 + starting_bombs: 3 +rewards: + collect_mission: 5.0 + attack_kill: 10.0 + destroy_enemy_base: 50.0 +``` + +Load a custom config: + +```python +from til_environment.config import load_config +from til_environment.bomberman_env import Bomberman + +env = Bomberman(load_config("my_config.yaml")) +``` + +Or use the default: + +```python +from til_environment.bomberman_env import basic_env + +env = basic_env() # includes FlattenDictWrapper + frame_stack_v2 +``` + +--- + +## Tests + +```bash +uv run pytest til_environment/tests/ -v +``` + +The test suite covers bomb placement and detonation, destructible wall behaviour, resource/bomb economy, agent freeze and respawn, termination conditions, action masking, and the Perlin respawn map. diff --git a/til-26-ae-repo/til-26-ae/__init__.py b/til-26-ae-repo/til-26-ae/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/til-26-ae-repo/til-26-ae/lefthook.yml b/til-26-ae-repo/til-26-ae/lefthook.yml new file mode 100644 index 0000000000000000000000000000000000000000..5167b2b909de0ae10a63b04eca95d4d4b82273d1 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/lefthook.yml @@ -0,0 +1,13 @@ +# lefthook.yml + +pre-commit: + parallel: true + jobs: + - run: uv run ruff check --fix {staged_files} + glob: "*.py" + stage_fixed: true + - run: uv run ruff format {staged_files} + glob: "*.py" + stage_fixed: true + - run: uv run pylint --errors-only {staged_files} + glob: "*.py" diff --git a/til-26-ae-repo/til-26-ae/play.py b/til-26-ae-repo/til-26-ae/play.py new file mode 100644 index 0000000000000000000000000000000000000000..6a78338919845dbb1ecae93d602ad7b87343756a --- /dev/null +++ b/til-26-ae-repo/til-26-ae/play.py @@ -0,0 +1,253 @@ +""" +play.py - Play the game yourself! + +Controls +-------- + W / ↑ β€” FORWARD + S / ↓ β€” BACKWARD + A / ← β€” turn LEFT + D / β†’ β€” turn RIGHT + SPACE β€” STAY + B / F β€” PLACE_BOMB + R β€” reset the environment + T β€” toggle respawn-timer overlay + Q / ESC β€” quit + + LEFT CLICK on an agent β€” take control of that agent at next round + LEFT CLICK on anything β€” print entity info to terminal + +Non selected entities do random actions. +Pass --verbose / -v to print action masks and per-step reward breakdowns. +""" + +import argparse +import random + +import pygame + +from til_environment.actions import Action +from til_environment.config import default_config, load_config +from til_environment.entities import Agent, Bomb, Resource +from til_environment.bomberman_env import Bomberman + + +KEY_TO_AGENT_ACTION = { + pygame.K_w: Action.FORWARD, + pygame.K_UP: Action.FORWARD, + pygame.K_s: Action.BACKWARD, + pygame.K_DOWN: Action.BACKWARD, + pygame.K_a: Action.LEFT, + pygame.K_LEFT: Action.LEFT, + pygame.K_d: Action.RIGHT, + pygame.K_RIGHT: Action.RIGHT, + pygame.K_SPACE: Action.STAY, + pygame.K_b: Action.PLACE_BOMB, + pygame.K_f: Action.PLACE_BOMB, +} + +FILLER_ACTION = int(Action.STAY) + + +def _entity_info(entity) -> str: + lines = [ + f"[{type(entity).__name__}] id={entity.entity_id}", + f" team={entity.team} pos={entity.position.tolist()}", + ] + if isinstance(entity, Agent): + lines += [ + f" health={entity.health:.0f}/{entity.max_health:.0f}", + f" direction={entity.direction}", + f" frozen_ticks={entity.frozen_ticks}", + ] + elif isinstance(entity, Bomb): + lines += [ + f" timer={entity.timer} attack={entity.attack} " + f"blast_radius={entity.blast_radius}", + f" placed_by={entity.attribute_rewards}", + ] + elif isinstance(entity, Resource): + lines.append(f" amount={entity.amount}") + elif hasattr(entity, "health"): + lines.append(f" health={entity.health:.0f}/{entity.max_health:.0f}") + if hasattr(entity, "reward_value"): + lines.append(f" reward_value={entity.reward_value}") + return "\n".join(lines) + + +def _print_action_mask(env: Bomberman, agent_id: str) -> None: + obs = env.observe(agent_id) + mask = obs.get("action_mask") + if mask is None: + return + available = [a.name for a in Action if mask[a]] + blocked = [a.name for a in Action if not mask[a]] + print(f" βœ“ {', '.join(available)}") + if blocked: + print(f" βœ— {', '.join(blocked)}") + print( + f" team_bombs={env.dynamics.team_bombs[env.dynamics.registry.get(agent_id).team]} " + f"team_resources={env.dynamics.team_resources[env.dynamics.registry.get(agent_id).team]:.2f}" + ) + + +def _handle_click(env: Bomberman, mouse_pos, player_agent: str, pending: str) -> str: + entity = env.renderer.hit_test(mouse_pos[0], mouse_pos[1], env.dynamics.registry) + if entity is None: + print("[click] empty tile") + return pending + if isinstance(entity, Agent): + if entity.entity_id != player_agent: + print(f"[click] will control {entity.entity_id} from next round") + else: + print(f"[click] already controlling {entity.entity_id}") + print(_entity_info(entity)) + return entity.entity_id + print("[click]") + print(_entity_info(entity)) + return pending + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument( + "--config", + type=str, + default=None, + help="Path to config YAML file (defaults to til_environment/bomberman_config.yaml)", + ) + parser.add_argument( + "--verbose", "-v", + action="store_true", + help="Print action masks and per-step reward breakdowns.", + ) + args = parser.parse_args() + verbose: bool = args.verbose + + if args.config is None: + cfg = default_config() + cfg.env.render_mode = "human" + else: + cfg = load_config(args.config) + + cfg.env.novice = True + env = Bomberman(cfg) + env.reset(seed=random.randint(0, 99999)) + + player_agent = env.possible_agents[0] + pending_player_agent = player_agent + print(f"Controlling: {player_agent} (click another agent to switch)") + + running = True + clock = pygame.time.Clock() + show_respawn_overlay = False + + while running: + agent = env.agent_selection + + is_new_round = env.agent_selector.is_first() + if is_new_round: + if pending_player_agent != player_agent: + player_agent = pending_player_agent + print(f"Now controlling: {player_agent}") + + _overlay = env.dynamics.respawn_map if show_respawn_overlay else None + env.render(selected_agent_id=player_agent, respawn_overlay=_overlay) + + clock.tick(env.cfg.renderer.render_fps) + + if env.terminations[agent] or env.truncations[agent]: + env.step(None) + if all(env.terminations.values()) or all(env.truncations.values()): + print("\n── episode over ──") + for a in env.possible_agents: + print(f" {a} reward={env.rewards.get(a, 0):.2f}") + print("Press R to reset or Q to quit.\n") + waiting = True + while waiting: + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + waiting = False + if event.type == pygame.KEYDOWN: + if event.key in (pygame.K_q, pygame.K_ESCAPE): + running = False + waiting = False + elif event.key == pygame.K_r: + env.reset(seed=random.randint(0, 99999)) + player_agent = env.possible_agents[0] + pending_player_agent = player_agent + waiting = False + if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: + pending_player_agent = _handle_click( + env, event.pos, player_agent, pending_player_agent + ) + continue + + if agent == player_agent: + if verbose: + _print_action_mask(env, agent) + agent_action = None + while agent_action is None: + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + agent_action = Action.STAY + if event.type == pygame.KEYDOWN: + if event.key in (pygame.K_q, pygame.K_ESCAPE): + running = False + agent_action = Action.STAY + elif event.key == pygame.K_r: + env.reset(seed=random.randint(0, 99999)) + player_agent = env.possible_agents[0] + pending_player_agent = player_agent + agent_action = None + break + elif event.key == pygame.K_t: + show_respawn_overlay = not show_respawn_overlay + print(f"[respawn overlay] {'ON' if show_respawn_overlay else 'OFF'}") + elif event.key in KEY_TO_AGENT_ACTION: + agent_action = KEY_TO_AGENT_ACTION[event.key] + if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: + pending_player_agent = _handle_click( + env, event.pos, player_agent, pending_player_agent + ) + _overlay = env.dynamics.respawn_map if show_respawn_overlay else None + env.render(selected_agent_id=player_agent, respawn_overlay=_overlay) + if not running: + break + env.step(int(agent_action)) + else: + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + if event.type == pygame.KEYDOWN: + if event.key in (pygame.K_q, pygame.K_ESCAPE): + running = False + elif event.key == pygame.K_r: + env.reset(seed=random.randint(0, 99999)) + player_agent = env.possible_agents[0] + pending_player_agent = player_agent + elif event.key == pygame.K_t: + show_respawn_overlay = not show_respawn_overlay + print(f"[respawn overlay] {'ON' if show_respawn_overlay else 'OFF'}") + if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: + pending_player_agent = _handle_click( + env, event.pos, player_agent, pending_player_agent + ) + env.step(FILLER_ACTION) + + if verbose: + print( + "step rewards:", + {a: f"{r:.2f}" for a, r in env.dynamics.rewards._step.items()}, + ) + print( + "ep rewards:", + {a: f"{r:.2f}" for a, r in env.dynamics.rewards._episode.items()}, + ) + env.close() + print("Done.") + + +if __name__ == "__main__": + main() diff --git a/til-26-ae-repo/til-26-ae/pyproject.toml b/til-26-ae-repo/til-26-ae/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..acfbd5e4d67cb080a074c8fb6a936969dc267d53 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/pyproject.toml @@ -0,0 +1,45 @@ +[build-system] +requires = ["setuptools >= 75.0"] +build-backend = "setuptools.build_meta" + +[project] +name = "til_environment" +description = "RL environment for TIL-AI 2026." +version = "1.4.0a1" +dependencies = [ + "gymnasium==1.1.1", + "pygame>=2.1.3", + "pettingzoo==1.25.0", + "mazelib==0.9.16", + "supersuit==3.9.3", + "omegaconf>=2.3.0", + "imageio[ffmpeg]>=2.28", + "perlin-noise>=1.14", +] +requires-python = ">=3.10" + + +[tool.uv.workspace] +members = [ + "selfplay", + "selfplay/til-26-ae", +] + +[tool.setuptools.packages.find] +where = ["."] + +[dependency-groups] +dev = [ + "ipykernel>=7.2.0", + "lefthook>=2.1.6", + "matplotlib>=3.10.9", + "pylint>=4.0.5", + "pytest>=9.0.3", + "ruff>=0.15.11", +] + +[tool.ruff.lint] +ignore = ["F401", "E501", "E722"] + +[tool.pylint] +extension-pkg-whitelist="pygame" diff --git a/til-26-ae-repo/til-26-ae/requirements.txt b/til-26-ae-repo/til-26-ae/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..80dce63388425cc16144f6bef6353745aed6be02 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/requirements.txt @@ -0,0 +1,56 @@ +# This file was autogenerated by uv via the following command: +# uv export --format requirements-txt --no-hashes --no-dev +-e . +antlr4-python3-runtime==4.9.3 + # via omegaconf +cloudpickle==3.1.2 + # via gymnasium +cython==3.2.4 + # via mazelib +farama-notifications==0.0.4 + # via gymnasium +gymnasium==1.1.1 + # via + # pettingzoo + # supersuit + # til-environment +imageio==2.37.3 + # via til-environment +imageio-ffmpeg==0.6.0 + # via imageio +mazelib==0.9.16 + # via til-environment +numpy==2.2.6 ; python_full_version < '3.11' + # via + # gymnasium + # imageio + # mazelib + # pettingzoo + # supersuit + # tinyscaler +numpy==2.4.4 ; python_full_version >= '3.11' + # via + # gymnasium + # imageio + # mazelib + # pettingzoo + # supersuit + # tinyscaler +omegaconf==2.3.0 + # via til-environment +pettingzoo==1.25.0 + # via til-environment +pillow==12.2.0 + # via imageio +psutil==7.2.2 + # via imageio +pygame==2.6.1 + # via til-environment +pyyaml==6.0.3 + # via omegaconf +supersuit==3.9.3 + # via til-environment +tinyscaler==1.2.8 + # via supersuit +typing-extensions==4.15.0 + # via gymnasium diff --git a/til-26-ae-repo/til-26-ae/til_environment.egg-info/PKG-INFO b/til-26-ae-repo/til-26-ae/til_environment.egg-info/PKG-INFO new file mode 100644 index 0000000000000000000000000000000000000000..3242c4a48422d4e537623bdb5ab6a61b45444445 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment.egg-info/PKG-INFO @@ -0,0 +1,15 @@ +Metadata-Version: 2.4 +Name: til_environment +Version: 1.4.0a1 +Summary: RL environment for TIL-AI 2026. +Requires-Python: >=3.10 +License-File: LICENSE +Requires-Dist: gymnasium==1.1.1 +Requires-Dist: pygame>=2.1.3 +Requires-Dist: pettingzoo==1.25.0 +Requires-Dist: mazelib==0.9.16 +Requires-Dist: supersuit==3.9.3 +Requires-Dist: omegaconf>=2.3.0 +Requires-Dist: imageio[ffmpeg]>=2.28 +Requires-Dist: perlin-noise>=1.14 +Dynamic: license-file diff --git a/til-26-ae-repo/til-26-ae/til_environment.egg-info/SOURCES.txt b/til-26-ae-repo/til-26-ae/til_environment.egg-info/SOURCES.txt new file mode 100644 index 0000000000000000000000000000000000000000..15ccef2bfa9a1e7fa171b6958cc1da9a5ca66bce --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment.egg-info/SOURCES.txt @@ -0,0 +1,29 @@ +LICENSE +README.md +pyproject.toml +til_environment/__init__.py +til_environment/actions.py +til_environment/arena.py +til_environment/bomberman_env.py +til_environment/config.py +til_environment/dynamics.py +til_environment/flatten_dict.py +til_environment/helpers.py +til_environment/observation.py +til_environment/renderer.py +til_environment/types.py +til_environment.egg-info/PKG-INFO +til_environment.egg-info/SOURCES.txt +til_environment.egg-info/dependency_links.txt +til_environment.egg-info/requires.txt +til_environment.egg-info/top_level.txt +til_environment/entities/__init__.py +til_environment/entities/base.py +til_environment/entities/dynamic.py +til_environment/entities/geometry.py +til_environment/entities/protocols.py +til_environment/entities/registry.py +til_environment/entities/static.py +til_environment/events/__init__.py +til_environment/events/base.py +til_environment/events/rewards.py \ No newline at end of file diff --git a/til-26-ae-repo/til-26-ae/til_environment.egg-info/dependency_links.txt b/til-26-ae-repo/til-26-ae/til_environment.egg-info/dependency_links.txt new file mode 100644 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/til-26-ae-repo/til-26-ae/til_environment.egg-info/requires.txt b/til-26-ae-repo/til-26-ae/til_environment.egg-info/requires.txt new file mode 100644 index 0000000000000000000000000000000000000000..b2b05c4fbea263eec1411891dd6858a5d50cd5b0 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment.egg-info/requires.txt @@ -0,0 +1,8 @@ +gymnasium==1.1.1 +pygame>=2.1.3 +pettingzoo==1.25.0 +mazelib==0.9.16 +supersuit==3.9.3 +omegaconf>=2.3.0 +imageio[ffmpeg]>=2.28 +perlin-noise>=1.14 diff --git a/til-26-ae-repo/til-26-ae/til_environment.egg-info/top_level.txt b/til-26-ae-repo/til-26-ae/til_environment.egg-info/top_level.txt new file mode 100644 index 0000000000000000000000000000000000000000..212410e90d912af3f33f48ee36b67eb7aa56dc3a --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment.egg-info/top_level.txt @@ -0,0 +1 @@ +til_environment diff --git a/til-26-ae-repo/til-26-ae/til_environment/__init__.py b/til-26-ae-repo/til-26-ae/til_environment/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..c060c19ecaefdf84edaee0edcddbb8df16f7bcae --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/__init__.py @@ -0,0 +1 @@ +from . import bomberman_env, flatten_dict, helpers, types # noqa: F401 diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/__init__.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ac1bc4bd91c04d6a43cf96edf3a53077a6653c8c Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/__init__.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/actions.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/actions.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2ac3f97ee7f6b71086e783f4b25c064c1617db5f Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/actions.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/arena.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/arena.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7d953ae43e2053ad06577989352fbe044580a537 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/arena.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/bomberman_env.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/bomberman_env.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7869a1e4cf4a66df285d82d3f95089f003f94203 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/bomberman_env.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/config.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/config.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..89d268190b6e46b693b7e16bc605a3b99e953efa Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/config.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/dynamics.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/dynamics.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..04b8894b1fe267b0cf114157cc588e30c4378871 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/dynamics.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/flatten_dict.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/flatten_dict.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1bc80ff2bed7c72f61cb092fa308a79a4e4b99fd Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/flatten_dict.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/helpers.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/helpers.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9a02ef2b66bf3f82d03d11f81ef50fa631c29941 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/helpers.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/observation.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/observation.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..7700aa9ed4dc5374727f02013c16445545833311 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/observation.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/renderer.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/renderer.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..829f4a265e25ad3e3040ec72f846404032f18896 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/renderer.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/__pycache__/types.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/types.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fa021cd4f711218af3a0168e7600394e558d2a4 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/__pycache__/types.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/actions.py b/til-26-ae-repo/til-26-ae/til_environment/actions.py new file mode 100644 index 0000000000000000000000000000000000000000..af512af85e597238de04ebadb65cc7fa80207da7 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/actions.py @@ -0,0 +1,133 @@ +""" +actions.py - Action definitions and action-mask system for Bomberman. + +Defines: +* ``Action`` β€” agent actions (movement, stay, place_bomb). +* ``ActionGroup`` β€” categorical grouping for mutual-exclusion rules. +* ``ActionMask`` β€” mask builder enforcing per-tick legality. +""" + +from __future__ import annotations + +from enum import IntEnum, auto +from typing import TYPE_CHECKING, Callable +from til_environment.types import Direction +import numpy as np + +if TYPE_CHECKING: + from til_environment.dynamics import Dynamics + from til_environment.entities import Agent + + +# --------------------------------------------------------------------------- +# Action groups (mutual-exclusion categories) +# --------------------------------------------------------------------------- +class ActionGroup(IntEnum): + MOVEMENT = auto() # FORWARD, BACKWARD, LEFT, RIGHT + IDLE = auto() # STAY + COMBAT = auto() # PLACE_BOMB + + +# --------------------------------------------------------------------------- +# Action enum +# --------------------------------------------------------------------------- +class Action(IntEnum): + """All actions an agent can take in a single step.""" + + FORWARD = 0 + BACKWARD = 1 + LEFT = 2 + RIGHT = 3 + STAY = 4 + PLACE_BOMB = 5 + + @property + def group(self) -> ActionGroup: + _GROUP_MAP = { + Action.FORWARD: ActionGroup.MOVEMENT, + Action.BACKWARD: ActionGroup.MOVEMENT, + Action.LEFT: ActionGroup.MOVEMENT, + Action.RIGHT: ActionGroup.MOVEMENT, + Action.STAY: ActionGroup.IDLE, + Action.PLACE_BOMB: ActionGroup.COMBAT, + } + return _GROUP_MAP[self] + + +NUM_ACTIONS_V2 = len(Action) + + +# --------------------------------------------------------------------------- +# ActionMask +# --------------------------------------------------------------------------- +class ActionMask: + """ + Builds and validates per-agent action masks. + + If you properly read and discovered the code, this should render agent_collide_wall and agent_collide_agent + """ + + def __init__(self, dynamics: "Dynamics") -> None: + self._dyn = dynamics + + def build(self, agent_id: str) -> np.ndarray: + """Return action mask for *agent_id*. Shape ``(NUM_ACTIONS_V2,)``.""" + from til_environment.entities import Agent as AgentCls + + agent = self._dyn.registry.get(agent_id) + if not isinstance(agent, AgentCls) or not agent.alive: + return np.zeros(NUM_ACTIONS_V2, dtype=np.int8) + if agent.is_frozen: + # Frozen agents may only STAY β€” all-zeros would confuse AEC wrappers + # that interpret a fully-masked agent as "dead, send None". + mask = np.zeros(NUM_ACTIONS_V2, dtype=np.int8) + mask[Action.STAY] = np.int8(1) + return mask + + mask = np.zeros(NUM_ACTIONS_V2, dtype=np.int8) + for action in Action: + validator = self._VALIDATORS.get(action) + if validator is not None: + mask[action.value] = np.int8(validator(self, agent)) + else: + mask[action.value] = np.int8(1) + return mask + + def validate(self, agent_id: str, action: int) -> bool: + mask = self.build(agent_id) + return bool(mask[action]) + + # -- per-action validators --------------------------------------------- + + def _can_forward(self, agent: "Agent") -> bool: + direction = Direction(agent.direction) + return not self._dyn._blocks_movement(agent, direction) + + def _can_backward(self, agent: "Agent") -> bool: + direction = Direction((agent.direction + 2) % 4) + return not self._dyn._blocks_movement(agent, direction) + + def _can_left(self, agent: "Agent") -> bool: + return True + + def _can_right(self, agent: "Agent") -> bool: + return True + + def _can_stay(self, agent: "Agent") -> bool: + return True + + def _can_place_bomb(self, agent: "Agent") -> bool: + """PLACE_BOMB is legal only if the team has at least one bomb available.""" + return self._dyn.team_bombs.get(agent.team, 0) > 0 + + _VALIDATORS: dict[Action, "_ValidatorFn"] = { + Action.FORWARD: _can_forward, + Action.BACKWARD: _can_backward, + Action.LEFT: _can_left, + Action.RIGHT: _can_right, + Action.STAY: _can_stay, + Action.PLACE_BOMB: _can_place_bomb, + } + + +_ValidatorFn = Callable[["ActionMask", "Agent"], bool] diff --git a/til-26-ae-repo/til-26-ae/til_environment/arena.py b/til-26-ae-repo/til-26-ae/til_environment/arena.py new file mode 100644 index 0000000000000000000000000000000000000000..6a2fb63919d7c430c1cc598eec21abb386da5c4a --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/arena.py @@ -0,0 +1,1255 @@ +""" +arena.py - Maze-based arena generation for the TIL Bomberman environment. + +This module owns the procedural generation of the game map: + +* ``ArenaGenerator`` – builds a randomised maze, places tile types, computes + wall edge-sets, and assigns starting positions for agents and bases. +* ``WallResult`` – cached wall layout (wall grid + edge set). +* ``StaticEntitySpec`` – lightweight spec for a static entity to be spawned. +* ``ArenaResult`` – lightweight dataclass that bundles everything the + ``Dynamics`` class needs to populate the world after a reset. + +Generation is split into two stages: + +1. **Wall generation** (``generate_walls``) – runs the Recursive Backtracking + maze algorithm and produces a ``uint8`` grid whose bits 0–3 encode wall + presence per edge (RIGHT=0, DOWN=1, LEFT=2, UP=3, matching + ``Direction.value``). Bits 4–7 flag which of those edges are destructible. + This result is **cached** on the ``ArenaGenerator`` instance; it is only + recomputed when the seed changes. + +2. **Episode generation** (``generate_episode``) – takes the cached wall + layout and independently scatters static entities (missions, recon tokens, + powerups) and assigns starting positions for agents/bases. Run on every + ``Dynamics.reset()`` call so entities are fresh each episode even if walls + are reused. + +Extracted from ``dynamics.py`` for readability; Dynamics imports and +composes an ``ArenaGenerator`` instance. +""" + +from __future__ import annotations + +import logging +import math +from dataclasses import dataclass + +import numpy as np +from gymnasium.utils.seeding import np_random +from mazelib import Maze +from mazelib.generate.DungeonRooms import DungeonRooms +from perlin_noise import PerlinNoise +from til_environment.helpers import convert_tile_to_edge, get_bit, is_world_coord_valid +from til_environment.types import Direction + +logger = logging.getLogger(__name__) + + +# ═══════════════════════════════════════════════════════════════════════════ +# WallEdge β€” first-class wall object with a canonical half-integer position +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class WallEdge: + """A single wall edge between two adjacent grid tiles. + + *ax, ay* is always the tile with lower coordinates (the first element of + the sorted ``((ax,ay),(bx,by))`` edge-key). *direction* is therefore + always RIGHT (dx=+1) or DOWN (dy=+1) β€” never LEFT or UP. This gives every + interior wall a single canonical object rather than a pair of bits spread + across two tiles. + + *position* is the half-integer world-space midpoint, e.g. (4.5, 4) for + a RIGHT wall starting at tile (4, 4). This is used to query whether a wall + falls within a viewcone or blast radius without referencing either tile + separately. + """ + + ax: int + ay: int + direction: "Direction" # RIGHT or DOWN only + destructible: bool = False + + @property + def bx(self) -> int: + return self.ax + (1 if self.direction == Direction.RIGHT else 0) + + @property + def by(self) -> int: + return self.ay + (1 if self.direction == Direction.DOWN else 0) + + @property + def position(self) -> tuple[float, float]: + """Half-integer world-space midpoint of this wall edge.""" + if self.direction == Direction.RIGHT: + return (self.ax + 0.5, float(self.ay)) + return (float(self.ax), self.ay + 0.5) + + +# ═══════════════════════════════════════════════════════════════════════════ +# WallResult β€” cached output of the wall-generation stage +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class WallResult: + """Output of the (cached) wall-generation stage. + + Attributes + ---------- + wall_grid : np.ndarray + ``(grid_size, grid_size)`` uint8 array. Bits 0–3 encode wall + presence per edge (RIGHT=0, DOWN=1, LEFT=2, UP=3). Bits 4–7 flag + which of those edges are destructible (same direction order). + walls : set + Set of ordered-pair edges ``((x0,y0),(x1,y1))`` for O(1) LOS + look-ups. + seed : int | None + The RNG seed used to produce this layout (used to detect staleness). + num_teams : int + Team count baked into the layout (used to detect cache staleness + when the symmetry fold changes between episodes). + """ + + wall_grid: np.ndarray + walls: set[tuple[tuple[int, int], tuple[int, int]]] + seed: int | None + num_teams: int = 1 + + +# ═══════════════════════════════════════════════════════════════════════════ +# StaticEntitySpec β€” lightweight spawn descriptor for static entities +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class StaticEntitySpec: + """Describes a single static entity to be placed on the map. + + ``kind`` is one of ``"mission"``, ``"recon"``, ``"resource"``, or + ``"destructible_wall"``. Multiple specs can share the same position + (e.g. a mission and a resource on the same tile β€” though see + ``generate_static_layer`` for the actual non-overlap rules). + """ + + kind: str + position: np.ndarray + + +# ═══════════════════════════════════════════════════════════════════════════ +# ArenaResult +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class ArenaResult: + """Bundle returned by ``ArenaGenerator.generate_episode``. + + Attributes + ---------- + wall_grid : np.ndarray + ``(grid_size, grid_size)`` uint8 array. Bits 0–3 encode wall + presence; bits 4–7 flag destructible edges. The canonical + ``_state`` array used by Dynamics. + walls : set + Set of ordered-pair edges for O(1) collision look-ups. + static_entities : list[StaticEntitySpec] + Static entities to instantiate in the EntityRegistry (missions, + recon tokens, powerups). Dynamic entities (agents, bases, scouts, + beacons) are NOT included here. + starting_directions : np.ndarray + ``(num_agents,)`` int array of initial facing directions. + starting_locations : np.ndarray + ``(num_agents, 2)`` int array of initial ``(x, y)`` positions. + base_locations : np.ndarray + ``(num_teams, 2)`` int array of base positions. + """ + + wall_grid: np.ndarray + walls: set[tuple[tuple[int, int], tuple[int, int]]] + static_entities: list[StaticEntitySpec] + starting_directions: np.ndarray + starting_locations: np.ndarray + base_locations: np.ndarray + respawn_map: np.ndarray + + +# ═══════════════════════════════════════════════════════════════════════════ +# ArenaState β€” mutable wall state owned by Dynamics +# ═══════════════════════════════════════════════════════════════════════════ +class ArenaState: + """Encapsulates the mutable wall state of the arena. + + ``Dynamics`` composes one ``ArenaState`` and delegates all wall queries + and mutations here, keeping wall logic out of the main ``Dynamics`` class. + + The ``_state`` array is a mutable ``uint8`` grid where bits 0–3 encode + wall presence in each ``Direction`` (bit index == ``Direction.value``). + The ``walls`` edge-set mirrors ``_state`` for O(1) LOS look-ups; + the two are always kept in sync. + + Parameters + ---------- + grid_size : int + Side-length of the square grid. + wall_grid : np.ndarray + Canonical (immutable) wall grid produced by ``ArenaGenerator``. + Stored as ``_arena``; ``_state`` is a mutable copy. + walls : set + Initial edge-set produced by ``ArenaGenerator``. + """ + + def __init__( + self, + grid_size: int, + wall_grid: np.ndarray, + walls: set[tuple[tuple[int, int], tuple[int, int]]], + ) -> None: + self.grid_size = grid_size + self._arena: np.ndarray = wall_grid # original β€” never mutated + # _state bit layout: + # bits 0-3: wall presence (RIGHT=0, BOTTOM=1, LEFT=2, TOP=3) + # bits 4-7: wall is destructible (same direction order) + # A wall is destructible iff BOTH its presence bit AND its +4 bit are set. + self._state: np.ndarray = wall_grid.copy() # mutable working copy + self.walls: set[tuple[tuple[int, int], tuple[int, int]]] = walls + + # wall_edges: one WallEdge per edge whose canonical tile (ax, ay) is + # within the grid. Boundary walls whose neighbour is out of bounds + # (RIGHT/DOWN edges at the grid border) are included; LEFT/UP edges at + # the top/left border have a negative canonical tile and are excluded. + self.wall_edges: dict[tuple, WallEdge] = {} + for edge in walls: + (ax, ay), (bx, by) = edge + if not (0 <= ax < grid_size and 0 <= ay < grid_size): + continue + dx, dy = bx - ax, by - ay + canonical_dir = Direction.RIGHT if dx == 1 else Direction.DOWN + d = canonical_dir.value + destr = bool(int(wall_grid[ax, ay]) & (1 << (d + 4))) + self.wall_edges[edge] = WallEdge( + ax=ax, ay=ay, direction=canonical_dir, destructible=destr + ) + + # -- wall helpers ---------------------------------------------------------- + + def _wall_edge(self, x: int, y: int, direction: Direction) -> tuple: + """Canonical edge key for the wall between (x, y) and its neighbour.""" + mv = direction.movement + return tuple(sorted(((x, y), (x + int(mv[0]), y + int(mv[1]))))) + + def enforce_wall_collision( + self, position: np.ndarray, direction: Direction + ) -> bool: + """Return True if moving *direction* from *position* is wall-blocked.""" + tile_val = self._state[tuple(position)] + if get_bit(tile_val, direction.value): + return True + next_loc = position + direction.movement + if not is_world_coord_valid(next_loc, self.grid_size): + return True + next_tile_val = self._state[tuple(next_loc)] + if get_bit(next_tile_val, (direction.value + 2) % 4): + return True + return False + + def is_destructible(self, x: int, y: int, direction: Direction) -> bool: + """Return True if the wall edge in *direction* from (x, y) is destructible.""" + key = self._wall_edge(x, y, direction) + edge = self.wall_edges.get(key) + return edge is not None and edge.destructible + + def set_destructible( + self, x: int, y: int, direction: Direction, value: bool = True + ) -> None: + """Set or clear the destructible flag on the wall edge from (x, y). + + Updates both the ``WallEdge`` object and the ``_state`` bits so every + consumer (blast, observation, renderer) stays in sync. No-op if no + wall exists at this edge. + """ + key = self._wall_edge(x, y, direction) + we = self.wall_edges.get(key) + if we is None: + return + we.destructible = value + b = direction.value + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if value: + self._state[x, y] = np.uint8(int(self._state[x, y]) | (1 << (b + 4))) + if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size: + opp_b = (b + 2) % 4 + self._state[nx, ny] = np.uint8( + int(self._state[nx, ny]) | (1 << (opp_b + 4)) + ) + else: + self._state[x, y] = np.uint8( + int(self._state[x, y]) & ~(1 << (b + 4)) & 0xFF + ) + if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size: + opp_b = (b + 2) % 4 + self._state[nx, ny] = np.uint8( + int(self._state[nx, ny]) & ~(1 << (opp_b + 4)) & 0xFF + ) + + @property + def indestructible_walls(self) -> frozenset: + """Wall edges that cannot be destroyed by bombs.""" + return frozenset( + key for key, we in self.wall_edges.items() if not we.destructible + ) + + def destroy_wall(self, x: int, y: int, direction: Direction) -> bool: + """Remove the wall on the *direction* edge of tile (x, y). + + Clears both the presence bit and the destructible bit. + ``_state``, ``walls``, and ``wall_edges`` are all updated atomically. + Returns True if a wall was present and removed; False if no-op. + """ + bit = direction.value + if not get_bit(int(self._state[x, y]), bit): + return False + clear = ~(1 << bit) & ~(1 << (bit + 4)) & 0xFF + self._state[x, y] = np.uint8(int(self._state[x, y]) & clear) + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size: + opp_bit = (direction.value + 2) % 4 + opp_clear = ~(1 << opp_bit) & ~(1 << (opp_bit + 4)) & 0xFF + self._state[nx, ny] = np.uint8(int(self._state[nx, ny]) & opp_clear) + edge_key = self._wall_edge(x, y, direction) + self.walls.discard(edge_key) + self.wall_edges.pop(edge_key, None) + return True + + def destroy_destructible_walls_in_radius(self, cells: list[np.ndarray]) -> int: + """Destroy every destructible wall edge touching any cell in *cells*. + + Returns the number of edges removed (each shared edge counted once). + Called by the detonation phase; only destructible edges are affected β€” + indestructible maze walls survive bomb blasts. + """ + count = 0 + for cell in cells: + x, y = int(cell[0]), int(cell[1]) + if not (0 <= x < self.grid_size and 0 <= y < self.grid_size): + continue + for direction in Direction: + if self.is_destructible(x, y, direction): + self.destroy_wall(x, y, direction) + count += 1 + return count + + def add_wall(self, x: int, y: int, direction: Direction) -> bool: + """Add a wall on the *direction* edge of tile (x, y). + + ``_state``, ``walls``, and ``wall_edges`` are all updated atomically. + Returns True if the wall was added; False if already present (no-op). + """ + bit = direction.value + if get_bit(int(self._state[x, y]), bit): + return False + self._state[x, y] = np.uint8(int(self._state[x, y]) | (1 << bit)) + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if 0 <= nx < self.grid_size and 0 <= ny < self.grid_size: + opp_bit = (direction.value + 2) % 4 + self._state[nx, ny] = np.uint8(int(self._state[nx, ny]) | (1 << opp_bit)) + edge_key = self._wall_edge(x, y, direction) + self.walls.add(edge_key) + if edge_key not in self.wall_edges: + (ax, ay), (bx, by) = edge_key + if 0 <= ax < self.grid_size and 0 <= ay < self.grid_size: + dx, dy = bx - ax, by - ay + canonical_dir = Direction.RIGHT if dx == 1 else Direction.DOWN + self.wall_edges[edge_key] = WallEdge( + ax=ax, ay=ay, direction=canonical_dir, destructible=False + ) + return True + + + +# ═══════════════════════════════════════════════════════════════════════════ +# ArenaGenerator +# ═══════════════════════════════════════════════════════════════════════════ +class ArenaGenerator: + """Encapsulates maze-based arena generation. + + Generation is split into two stages for efficiency: + + 1. ``generate_walls(rng, rng_seed)`` β€” expensive maze algorithm. + Result is cached and reused until the seed changes. + 2. ``generate_episode(rng, ...)`` β€” cheap static-entity scatter + + start-position assignment. Always runs on every episode reset. + + Parameters + ---------- + grid_size : int + Side-length of the square grid. + wall_prob : float + Fraction of interior maze walls to randomly knock down. + mission_prob : float + Per-tile probability of spawning a Mission entity. + recon_prob : float + Per-tile probability of spawning a Recon token (independent of + mission_prob; a cell may become either mission or recon but not both + β€” the outcome is drawn from a multinomial). + powerup_prob : float + Per-tile probability of spawning a PowerUp entity. Applied as a + second independent roll, so a tile can have a powerup alongside a + mission or recon token. + novice : bool + If True, use a fixed seed for reproducible maps. + """ + + def __init__( + self, + grid_size: int = 16, + wall_prob: float = 0.8, + wall_destructible_ratio: float = 0.5, + mission_prob: float = 0.2, + recon_prob: float = 0.15, + resource_prob: float = 0.08, + novice: bool = False, + base_respawn_steps: int = 40, + ) -> None: + self.grid_size = grid_size + self.wall_drop_prob = 1 - wall_prob + self.wall_destructible_ratio = wall_destructible_ratio + self.mission_prob = mission_prob + self.recon_prob = recon_prob + self.resource_prob = resource_prob + self.novice = novice + self.base_respawn_steps = base_respawn_steps + self._maze = Maze() + + # cached wall layout β€” None until first generate_walls() call + self._wall_cache: WallResult | None = None + + # -- public API --------------------------------------------------------- + + def generate_walls( + self, + rng: np.random.Generator, + rng_seed: int | None, + num_teams: int = 1, + phase_offset: float = 0.0, + ) -> WallResult: + """Generate (or retrieve from cache) the wall layout for a given seed. + + The maze algorithm is only re-run when the seed or ``num_teams`` + changes, or when no cached result exists. Rooms are pre-carved at + each team's approximate spawn location so corridors lead naturally + into the base areas. + + Returns + ------- + WallResult + Wall grid and edge set. + """ + if ( + self._wall_cache is not None + and self._wall_cache.seed == rng_seed + and self._wall_cache.num_teams == num_teams + and not self.novice + ): + return self._wall_cache + + if self.novice: + rng_for_maze, _ = np_random(19) + self._maze.set_seed(19 % 2**32) + else: + rng_for_maze = rng + self._maze.set_seed((rng_seed or 0) % 2**32) + + self._generate_maze_with_timeout(rng_for_maze, num_teams=num_teams, phase_offset=phase_offset) + # knock down some walls + grid = self._maze.grid.copy() + grid[0, :] = grid[-1, :] = grid[:, 0] = grid[:, -1] = 0 + grid *= np.indices(grid.shape).sum(axis=0) % 2 + wall_idx = np.where(grid == 1) + if wall_idx[0].shape[0] > 0: + drop = rng.choice( + wall_idx[0].shape[0], + size=int(wall_idx[0].shape[0] * self.wall_drop_prob), + replace=False, + ) + self._maze.grid[wall_idx[0][drop], wall_idx[1][drop]] = 0 + + # Bits 0–3: wall presence (RIGHT=0, DOWN=1, LEFT=2, UP=3 matching Direction.value). + # Bits 4–7: destructible flag for the same four edges. + wall_grid = np.zeros((self.grid_size, self.grid_size), dtype=np.uint8) + convert_tile_to_edge(wall_grid, self._maze.grid) + + walls = self._build_wall_set(wall_grid) + + # Mark a fraction of walls as destructible + self._mark_destructible_walls(wall_grid, walls, rng, num_teams) + + result = WallResult(wall_grid=wall_grid, walls=walls, seed=rng_seed, num_teams=num_teams) + self._wall_cache = result + return result + + def generate_static_layer( + self, + rng: np.random.Generator, + wall_grid: np.ndarray, + num_teams: int = 1, + phase_offset: float = 0.0, + ) -> list[StaticEntitySpec]: + """Scatter collectibles with N-fold rotational symmetry. + + Pass A β€” sector-0 cells, centre-biased Bernoulli, rotate to all N sectors. + Sector-0 is the angular wedge ``[phase_offset, phase_offset + 2Ο€/N)``. + Each cell's placement probability scales from 2Γ— at the grid centre + to 0.5Γ— at corners. Winning cells are batched; types are assigned + in **fixed proportion** (mission : recon : resource as configured) + using residual rounding, so the type mix is consistent across + episodes regardless of how many cells fired. + + Pass B β€” centre fill (radius ≀ 2.5), no rotation. + Any centre cell not yet occupied gets the same Bernoulli roll; types + assigned with the same budget method. + """ + specs: list[StaticEntitySpec] = [] + + mp = float(np.clip(self.mission_prob, 0.0, 1.0)) + rp = float(np.clip(self.recon_prob, 0.0, 1.0)) + sp = float(np.clip(self.resource_prob, 0.0, 1.0)) + base_coll = mp + rp + sp + if base_coll > 1.0: + mp /= base_coll + rp /= base_coll + sp /= base_coll + base_coll = 1.0 + + # Raw (already-clipped) probability per type name β€” normalization is + # deferred to _assign_types so subsets renormalize automatically. + type_probs: dict[str, float] = { + "mission": mp, + "recon": rp, + "resource": sp, + } + + ALL_WALLS_V2 = 0x0F + gs = self.grid_size + cx = (gs - 1) / 2.0 + cy = (gs - 1) / 2.0 + max_dist = math.sqrt(2.0) * (gs - 1) / 2.0 + theta_sector = 2.0 * math.pi / max(num_teams, 1) + + placed: set[tuple[int, int]] = set() + + def _add(kind: str, tx: int, ty: int, overwrite: bool = False) -> bool: + if (wall_grid[tx, ty] & ALL_WALLS_V2) == ALL_WALLS_V2: + return False + if (tx, ty) in placed: + if not overwrite: + return False + # Remove the existing spec so the centre placement takes priority. + for i in range(len(specs) - 1, -1, -1): + p = specs[i].position + if int(p[0]) == tx and int(p[1]) == ty: + specs.pop(i) + break + placed.discard((tx, ty)) + specs.append(StaticEntitySpec(kind=kind, position=np.array([tx, ty]))) + placed.add((tx, ty)) + return True + + # def _placement_prob(x: int, y: int) -> float: + # d_norm = min(1.0, math.sqrt((x - cx) ** 2 + (y - cy) ** 2) / max_dist) + # scale = 0.5 + 1.5 * (1.0 - d_norm) # 2.0 at centre, 0.5 at corners + # return min(0.9, base_coll * scale) + + def _assign_types( + cells: list[tuple[int, int]], + rotate: bool, + type_names: list[str] = ["mission", "recon", "resource"], + overwrite: bool = False, + ) -> None: + """Assign types to *cells* via residual rounding. + + Fractions are derived from ``type_probs`` restricted to *type_names* + and renormalized, so any subset of types is handled correctly. + When *overwrite* is True, cells already occupied by a pass-A tile + are replaced rather than skipped. + """ + n = len(cells) + if n == 0: + return + + raw_probs = [type_probs.get(t, 0.0) for t in type_names] + total = sum(raw_probs) + if total > 0.0: + fracs = [p / total for p in raw_probs] + else: + fracs = [1.0 / len(type_names)] * len(type_names) + + raw = [f * n for f in fracs] + counts = [int(r) for r in raw] + deficit = n - sum(counts) + residuals = [r - c for r, c in zip(raw, counts)] + for i in sorted(range(len(residuals)), key=lambda i: -residuals[i])[:deficit]: + counts[i] += 1 + + shuffled = list(cells) + rng.shuffle(shuffled) + idx = 0 + for kind, cnt in zip(type_names, counts): + for _ in range(cnt): + if idx >= len(shuffled): + break + x, y = shuffled[idx] + idx += 1 + if rotate: + for k in range(num_teams): + if k == 0: + _add(kind, x, y, overwrite=overwrite) + else: + rc = self._rotate_cell(x, y, k * theta_sector) + if rc is not None: + _add(kind, rc[0], rc[1], overwrite=overwrite) + else: + _add(kind, x, y, overwrite=overwrite) + + # --- Pass A: sector-0 cells, rotate to all sectors --- + sector0_hits: list[tuple[int, int]] = [] + for x, y in np.ndindex((gs, gs)): + if (wall_grid[x, y] & ALL_WALLS_V2) == ALL_WALLS_V2: + continue + angle = (math.atan2(y - cy, x - cx) - phase_offset) % (2.0 * math.pi) + if angle >= theta_sector: + continue + # if rng.random() < _placement_prob(x, y): + sector0_hits.append((x, y)) + _assign_types(sector0_hits, rotate=True) + + # --- Pass B: centre fill (radius ≀ 2.5) β€” overrides pass A placements --- + centre_hits: list[tuple[int, int]] = [] + for x, y in np.ndindex((gs, gs)): + if math.sqrt((x - cx) ** 2 + (y - cy) ** 2) > 2.5: + continue + if (wall_grid[x, y] & ALL_WALLS_V2) == ALL_WALLS_V2: + continue + centre_hits.append((x, y)) + _assign_types(centre_hits, rotate=False, type_names=["mission", "resource"], overwrite=True) + + return specs + + def generate_respawn_map(self, rng_seed: int | None) -> np.ndarray: + """Build a per-cell tile-respawn delay map using Perlin noise + a centre gradient. + + The result is a ``(grid_size, grid_size)`` int32 array where each value + is the number of steps before a collected tile at that position reappears. + Centre cells receive the shortest delays; peripheral cells receive delays + up to ``base_respawn_steps``. + + The approach (adapted from the noise.ipynb demo): + 1. Sample a Perlin noise field; boost the inner 4Γ—4 region to ensure + centre values are always positive. + 2. Build a circular gradient: 1.0 at the centre, 0.0 at the corners. + 3. Multiply noise Γ— gradient and amplify positive values so the centre + "plateau" dominates. + 4. Normalise to [0, 1] and map linearly to + [``base_respawn_steps``//4, ``base_respawn_steps``]. + """ + + gs = self.grid_size + base = self.base_respawn_steps + min_steps = max(base // 4, 5) + seed = (int(rng_seed) & 0x7FFFFFFF) if rng_seed is not None else 0 + + # ── 1. Perlin noise ───────────────────────────────────────────────── + noise_fn = PerlinNoise(octaves=4, seed=seed) + raw = np.array( + [[noise_fn([i / gs, j / gs]) for j in range(gs)] for i in range(gs)], + dtype=np.float64, + ) + # Centre bias: force inner 4Γ—4 positive so they always land fast. + c = gs // 2 + for i in range(c - 2, c + 2): + for j in range(c - 2, c + 2): + if 0 <= i < gs and 0 <= j < gs: + raw[i, j] = abs(raw[i, j]) + 0.2 + raw -= raw.min() + raw /= raw.max() + 1e-9 + + # ── 2. Circular centre gradient ───────────────────────────────────── + cx, cy = (gs - 1) / 2.0, (gs - 1) / 2.0 + ys, xs = np.mgrid[0:gs, 0:gs] + dist = np.sqrt((xs.astype(float) - cx) ** 2 + (ys.astype(float) - cy) ** 2) + grad = 1.0 - dist / (dist.max() + 1e-9) # 1 at centre, 0 at corners + grad = np.where(grad > 0, grad * 20.0, grad) + grad /= grad.max() + 1e-9 + grad = np.clip(grad, 0.0, 0.7) + grad /= grad.max() + 1e-9 # cap becomes 1.0 + + # ── 3. Combine ────────────────────────────────────────────────────── + combined = raw * grad + combined = np.where(combined > 0, combined * 5.0, combined) + combined -= combined.min() + combined /= combined.max() + 1e-9 # [0, 1], high = centre-like + + # ── 4. Map to steps ───────────────────────────────────────────────── + # combined = 1.0 β†’ min_steps (fast centre) + # combined = 0.0 β†’ base (slow periphery) + respawn_map = np.round( + min_steps + (base - min_steps) * (1.0 - combined) + ).astype(np.int32) + + return respawn_map + + def generate_episode( + self, + rng: np.random.Generator, + rng_seed: int | None, + num_teams: int = 2, + ) -> ArenaResult: + """Generate a complete episode setup. + + Calls (cached) ``generate_walls`` for the structural layout, then + freshly generates static entity placements and start positions. + + Parameters + ---------- + rng : np.random.Generator + rng_seed : int | None + Seed used to index into the wall cache. + num_teams : int + Number of competing teams (one agent + one base each). + + Returns + ------- + ArenaResult + """ + # Draw phase_offset first so the same value is used for both the maze + # room positions (generate_walls) and the spawn/collectible placement. + phase_offset = rng.uniform(0.0, 2.0 * math.pi / max(num_teams, 1)) + + wall_result = self.generate_walls(rng, rng_seed, num_teams=num_teams, phase_offset=phase_offset) + # Copy so we can mutate without corrupting the cache. + wall_grid = wall_result.wall_grid.copy() + walls: set = set(wall_result.walls) + + starting_directions = rng.integers(0, 4, size=num_teams) + base_locations, starting_locations = self._spread_spawns( + rng, + num_teams, + wall_grid, + phase_offset=phase_offset, + ) + self._ensure_base_destructible_walls(wall_grid, base_locations) + + static_entities = self.generate_static_layer( + rng, wall_grid, num_teams=num_teams, phase_offset=phase_offset + ) + static_entities = self._deconflict_spawn_tiles( + static_entities, starting_locations, base_locations + ) + + respawn_map = self.generate_respawn_map(rng_seed=rng_seed) + + return ArenaResult( + wall_grid=wall_grid, + walls=walls, + static_entities=static_entities, + starting_directions=starting_directions, + starting_locations=starting_locations, + base_locations=base_locations, + respawn_map=respawn_map, + ) + + # -- kept for backward compatibility ----------------------------------- + + def generate( + self, + rng: np.random.Generator, + rng_seed: int | None, + num_teams: int = 2, + ) -> ArenaResult: + """Backward-compatible alias for ``generate_episode``.""" + return self.generate_episode(rng, rng_seed, num_teams) + + # -- internal ----------------------------------------------------------- + + def _base_rooms(self, num_teams: int, phase_offset: float) -> list: + """Return DungeonRooms room specs centred on each team's spawn area.""" + gs = self.grid_size + cx, cy = (gs - 1) / 2.0, (gs - 1) / 2.0 + radius = gs * 0.38 # matches spawn_r in _spread_spawns + rooms = [] + for t in range(max(num_teams, 1)): + theta = phase_offset + 2.0 * math.pi * t / max(num_teams, 1) + gx = int(round(cx + radius * math.cos(theta))) + gy = int(round(cy + radius * math.sin(theta))) + # 2Γ—2 game-cell clearing β†’ odd maze-space corners (clamped to grid) + tl = (2 * max(0, gx - 1) + 1, 2 * max(0, gy - 1) + 1) + br = (2 * min(gs - 2, gx + 1) + 1, 2 * min(gs - 2, gy + 1) + 1) + rooms.append([tl, br]) + return rooms + + def _new_maze_generator( + self, rng: np.random.Generator, num_teams: int = 1, phase_offset: float = 0.0 + ): + return DungeonRooms( + self.grid_size, self.grid_size, + rooms=self._base_rooms(num_teams, phase_offset), + ) + + def _generate_maze_with_timeout( + self, rng: np.random.Generator, timeout: int = 2, retries: int = 5, + num_teams: int = 1, phase_offset: float = 0.0, + ) -> None: + for attempt in range(retries): + try: + self._maze.generator = self._new_maze_generator( + rng, num_teams=num_teams, phase_offset=phase_offset + ) + self._maze.generate() + return + except Exception as exc: + logger.warning("Maze gen attempt %d failed: %s", attempt, exc) + raise RuntimeError(f"Failed to generate maze after {retries} attempts") + + def _build_wall_set( + self, wall_grid: np.ndarray + ) -> set[tuple[tuple[int, int], tuple[int, int]]]: + """Build the edge-pair set from the wall grid (wall presence in bits 0–3).""" + gs = self.grid_size + walls: set[tuple[tuple[int, int], tuple[int, int]]] = set() + for x, y in np.ndindex((gs, gs)): + tile = wall_grid[x, y] + for direction in Direction: + if not get_bit(tile, direction.value): + continue + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if not (0 <= nx < gs and 0 <= ny < gs): + continue # skip border edges that point outside the grid + edge = tuple(sorted(((x, y), (nx, ny)))) + walls.add(edge) + return walls + + # ── rotational symmetry ──────────────────────────────────────────────── + + def _rotate_edge( + self, edge: tuple, theta: float + ) -> tuple[tuple[int, int], tuple[int, int]] | None: + """Rotate a wall edge by *theta* radians about the grid centre. + + Returns the canonically sorted edge tuple, or ``None`` if either + rotated endpoint falls outside the grid or if rounding collapses the + two endpoints to the same cell / into a diagonal (non-adjacent) pair. + """ + gs = self.grid_size + cx = (gs - 1) / 2.0 + cy = (gs - 1) / 2.0 + cos_t, sin_t = math.cos(theta), math.sin(theta) + + new_cells: list[tuple[int, int]] = [] + for ex, ey in edge: + rx, ry = ex - cx, ey - cy + nxi = int(round(cx + rx * cos_t - ry * sin_t)) + nyi = int(round(cy + rx * sin_t + ry * cos_t)) + if not (0 <= nxi < gs and 0 <= nyi < gs): + return None + new_cells.append((nxi, nyi)) + + # Discard non-adjacent results (rounding artifact for non-4-fold N). + (ax, ay), (bx, by) = new_cells + if abs(ax - bx) + abs(ay - by) != 1: + return None + + return tuple(sorted(new_cells)) + + def _rotate_cell(self, x: int, y: int, theta: float) -> tuple[int, int] | None: + """Rotate cell (x, y) by *theta* radians about the grid centre. + + Returns the rounded integer coordinate, or ``None`` if the result + falls outside the grid. + """ + gs = self.grid_size + cx = (gs - 1) / 2.0 + cy = (gs - 1) / 2.0 + cos_t, sin_t = math.cos(theta), math.sin(theta) + rx, ry = x - cx, y - cy + nxi = int(round(cx + rx * cos_t - ry * sin_t)) + nyi = int(round(cy + rx * sin_t + ry * cos_t)) + if not (0 <= nxi < gs and 0 <= nyi < gs): + return None + return (nxi, nyi) + + def _mark_destructible_walls( + self, + wall_grid: np.ndarray, + walls: set, + rng: np.random.Generator, + num_teams: int, + ) -> None: + """Mark ``wall_destructible_ratio`` fraction of edges as destructible. + + Each edge in *walls* receives an independent Bernoulli roll. + Destructibility is encoded in bits 4–7 of ``wall_grid`` (same + direction order as the presence bits in 0–3). Mutates in-place. + """ + ratio = float(np.clip(self.wall_destructible_ratio, 0.0, 1.0)) + if ratio <= 0: + return + + for edge in walls: + if rng.random() >= ratio: + continue + (ax, ay), (bx, by) = edge + dx, dy = bx - ax, by - ay + d = 0 if dx == 1 else 1 if dy == 1 else 2 if dx == -1 else 3 + wall_grid[ax, ay] = np.uint8(int(wall_grid[ax, ay]) | (1 << (d + 4))) + wall_grid[bx, by] = np.uint8(int(wall_grid[bx, by]) | (1 << ((d + 2) % 4 + 4))) + + def _ensure_connected( + self, wall_grid: np.ndarray, walls: set + ) -> tuple[np.ndarray, set]: + """Open walls until all cells form a single connected region. + + Each iteration BFS-floods from cell (0, 0). If any cell is + unreachable, the first frontier wall between the visited and + unvisited regions is removed and the loop restarts. Worst-case + O(G⁴) but in practice only a handful of walls need opening. + """ + gs = self.grid_size + + while True: + visited = np.zeros((gs, gs), dtype=bool) + stack = [(0, 0)] + visited[0, 0] = True + while stack: + x, y = stack.pop() + for direction in Direction: + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if 0 <= nx < gs and 0 <= ny < gs and not visited[nx, ny]: + if tuple(sorted(((x, y), (nx, ny)))) not in walls: + visited[nx, ny] = True + stack.append((nx, ny)) + + if visited.all(): + return wall_grid, walls + + # Find the first frontier wall. + frontier_edge = None + outer: bool = False + for x in range(gs): + for y in range(gs): + if not visited[x, y]: + continue + for direction in Direction: + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if 0 <= nx < gs and 0 <= ny < gs and not visited[nx, ny]: + e = tuple(sorted(((x, y), (nx, ny)))) + if e in walls: + frontier_edge = e + outer = True + break + if outer: + break + if outer: + break + + if frontier_edge is None: + return wall_grid, walls # cannot repair (shouldn't happen) + + walls.discard(frontier_edge) + (ax, ay), (bx, by) = frontier_edge + dx, dy = bx - ax, by - ay + d = 0 if dx == 1 else 1 if dy == 1 else 2 if dx == -1 else 3 + wall_grid[ax, ay] &= np.uint8(~(1 << d) & ~(1 << (d + 4)) & 0xFF) + wall_grid[bx, by] &= np.uint8(~(1 << (d + 2) % 4) & ~(1 << ((d + 2) % 4 + 4)) & 0xFF) + + # ── unified spawn placement ──────────────────────────────────────────── + + def _spread_spawns( + self, + rng: np.random.Generator, + num_teams: int, + wall_grid: np.ndarray, + phase_offset: float = 0.0, + ) -> tuple[np.ndarray, np.ndarray]: + """Place one base and one agent per team around the grid. + + Teams are distributed at equal angular intervals around the grid + centre, all at the **same radius**. + + Returns + ------- + base_locations : np.ndarray ``(num_teams, 2)`` + agent_locations : np.ndarray ``(num_teams, 2)`` + """ + gs = self.grid_size + + # continuous centre of the grid + cx = (gs - 1) / 2.0 + cy = (gs - 1) / 2.0 + + # spawn radius β€” 38% of the grid keeps bases well inside + # the border (~1-tile margin) while being far from centre. + spawn_r = 0.38 * gs + + # global set of occupied tiles (shared across all teams) + occupied: set[tuple[int, int]] = set() + + base_locs: list[np.ndarray] = [] + agent_locs: list[np.ndarray] = [] + + for t in range(num_teams): + # equal angular spacing with random phase so the orientation + # varies each episode + theta = phase_offset + 2.0 * math.pi * t / num_teams + ideal_x = cx + spawn_r * math.cos(theta) + ideal_y = cy + spawn_r * math.sin(theta) + + # snap to nearest integer tile, clamped inside the grid + anchor_x = int(np.clip(round(ideal_x), 0, gs - 1)) + anchor_y = int(np.clip(round(ideal_y), 0, gs - 1)) + + # ── place base ───────────────────────────────────────────── + base_pos = self._find_open_tile( + rng, + wall_grid, + anchor_x, + anchor_y, + occupied, + ) + if base_pos is None: + raise RuntimeError( + f"Could not place base for team {t} near ({anchor_x}, {anchor_y})." + ) + occupied.add(base_pos) + base_locs.append(np.array(base_pos)) + + # ── place agent near the base ────────────────────────────── + agent_pos = self._find_reachable_tile( + rng, + wall_grid, + (int(base_pos[0]), int(base_pos[1])), + occupied, + ) + if agent_pos is None: + raise RuntimeError( + f"Could not place agent for team {t} near base " + f"at {base_pos} β€” grid may be too crowded." + ) + occupied.add(agent_pos) + agent_locs.append(np.array(agent_pos)) + + return np.array(base_locs), np.array(agent_locs) + + @staticmethod + def _find_open_tile( + rng: np.random.Generator, + wall_grid: np.ndarray, + cx: int, + cy: int, + occupied: set[tuple[int, int]], + max_radius: int | None = None, + ) -> tuple[int, int] | None: + """Spiral outward from ``(cx, cy)`` to find the nearest open tile. + + An *open* tile is one that is not fully enclosed (i.e. does NOT have + walls on all four edges) and is not in ``occupied``. Searches + Chebyshev-distance shells at radius 0, 1, 2, … up to ``max_radius`` + (defaults to ``grid_size``). + + Within each shell the candidates are shuffled (via ``rng``) so that + ties don't consistently resolve in the same direction. + + Returns ``None`` if no open tile is found within the search radius. + """ + gs = wall_grid.shape[0] + limit = max_radius if max_radius is not None else gs + + for r in range(limit): + if r == 0: + candidates = [(cx, cy)] + else: + candidates = [] + for dx in range(-r, r + 1): + for dy in range(-r, r + 1): + if max(abs(dx), abs(dy)) != r: + continue # Chebyshev-distance shell + nx, ny = cx + dx, cy + dy + if 0 <= nx < gs and 0 <= ny < gs: + candidates.append((nx, ny)) + + # shuffle for fairness + rng.shuffle(candidates) + + for pos in candidates: + # A tile is blocked only when ALL four edges are walled. + # After the >>4 shift, wall bits live in the lower nibble. + _ALL = 0x0F # bits 0-3: RIGHT | BOTTOM | LEFT | TOP + if (wall_grid[pos[0], pos[1]] & _ALL) != _ALL and pos not in occupied: + return pos + + return None + + @staticmethod + def _find_reachable_tile( + rng: np.random.Generator, + wall_grid: np.ndarray, + start: tuple[int, int], + occupied: set[tuple[int, int]], + ) -> tuple[int, int] | None: + """BFS from *start* traversing only wall-free edges. + + Returns the nearest unoccupied reachable tile, shuffled within each + BFS distance level for fairness. Guarantees no structural wall lies + between *start* and the returned tile. + """ + gs = wall_grid.shape[0] + if start not in occupied: + return start + + visited: set[tuple[int, int]] = {start} + frontier: list[tuple[int, int]] = [start] + + while frontier: + nxt: list[tuple[int, int]] = [] + for x, y in frontier: + tile_val = int(wall_grid[x, y]) + for d in Direction: + if get_bit(tile_val, d.value): + continue + mv = d.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if not (0 <= nx < gs and 0 <= ny < gs): + continue + if get_bit(int(wall_grid[nx, ny]), (d.value + 2) % 4): + continue + if (nx, ny) not in visited: + visited.add((nx, ny)) + nxt.append((nx, ny)) + rng.shuffle(nxt) + for pos in nxt: + if pos not in occupied: + return pos + frontier = nxt + + return None + + def _ensure_base_destructible_walls( + self, + wall_grid: np.ndarray, + base_locations: np.ndarray, + min_count: int = 7, + radius: int = 1, + ) -> None: + """Guarantee each base has at least *min_count* destructible wall edges nearby. + + Collects all wall edges whose midpoint falls within Chebyshev *radius* + of the base tile. If fewer than *min_count* are already flagged + destructible, the closest non-destructible candidates are promoted + (bits 4–7 set) until the quota is met. Only mutates ``wall_grid``. + """ + gs = self.grid_size + for base_pos in base_locations: + bx, by = int(base_pos[0]), int(base_pos[1]) + + # Collect unique wall edges in the neighbourhood. + seen: set = set() + nearby: list[tuple] = [] # (midpoint_chebyshev_dist, edge_canonical) + for x in range(max(0, bx - radius), min(gs, bx + radius + 1)): + for y in range(max(0, by - radius), min(gs, by + radius + 1)): + tile = int(wall_grid[x, y]) + for d in Direction: + if not get_bit(tile, d.value): + continue + mv = d.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if not (0 <= nx < gs and 0 <= ny < gs): + continue + edge = tuple(sorted(((x, y), (nx, ny)))) + if edge in seen: + continue + seen.add(edge) + (ax, ay), (ex, ey) = edge + mid_dist = max(abs((ax + ex) / 2 - bx), abs((ay + ey) / 2 - by)) + nearby.append((mid_dist, edge)) + + # Partition into already-destructible and candidates. + destr_count = 0 + candidates: list[tuple] = [] + for dist, edge in nearby: + (ax, ay), (ex, ey) = edge + dx, dy = ex - ax, ey - ay + d = 0 if dx == 1 else 1 if dy == 1 else 2 if dx == -1 else 3 + if get_bit(int(wall_grid[ax, ay]), d + 4): + destr_count += 1 + else: + candidates.append((dist, edge)) + + need = min_count - destr_count + if need <= 0: + continue + + candidates.sort() + for _, edge in candidates[:need]: + (ax, ay), (ex, ey) = edge + dx, dy = ex - ax, ey - ay + d = 0 if dx == 1 else 1 if dy == 1 else 2 if dx == -1 else 3 + wall_grid[ax, ay] = np.uint8(int(wall_grid[ax, ay]) | (1 << (d + 4))) + wall_grid[ex, ey] = np.uint8(int(wall_grid[ex, ey]) | (1 << ((d + 2) % 4 + 4))) + + def _clear_base_area( + self, + wall_grid: np.ndarray, + walls: set, + base_locations: np.ndarray, + radius: int = 1, + ) -> None: + """Remove all structural wall edges incident to cells within *radius* of each base. + + Clears both internal walls (both endpoints inside the box) and perimeter + walls (one endpoint inside, one outside), so every side of the clearance + zone has at least one open entry point from the surrounding maze. + + Mutates *wall_grid* and *walls* in-place (caller must pass copies if the + originals are cached). + """ + gs = self.grid_size + for base_pos in base_locations: + bx, by = int(base_pos[0]), int(base_pos[1]) + x0 = max(0, bx - radius) + x1 = min(gs - 1, bx + radius) + y0 = max(0, by - radius) + y1 = min(gs - 1, by + radius) + for x in range(x0, x1 + 1): + for y in range(y0, y1 + 1): + for direction in Direction: + mv = direction.movement + nx, ny = x + int(mv[0]), y + int(mv[1]) + if not (0 <= nx < gs and 0 <= ny < gs): + continue + bit = direction.value + if not get_bit(int(wall_grid[x, y]), bit): + continue + clear = ~(1 << bit) & ~(1 << (bit + 4)) & 0xFF + wall_grid[x, y] = np.uint8(int(wall_grid[x, y]) & clear) + opp_bit = (bit + 2) % 4 + opp_clear = ~(1 << opp_bit) & ~(1 << (opp_bit + 4)) & 0xFF + wall_grid[nx, ny] = np.uint8(int(wall_grid[nx, ny]) & opp_clear) + walls.discard(tuple(sorted(((x, y), (nx, ny))))) + + def _deconflict_spawn_tiles( + self, + static_entities: list[StaticEntitySpec], + starting_locations: np.ndarray, + base_locations: np.ndarray, + ) -> list[StaticEntitySpec]: + """Remove static entities that share a tile with any spawn point.""" + excluded: set[tuple[int, int]] = set() + for loc in starting_locations: + excluded.add((int(loc[0]), int(loc[1]))) + for loc in base_locations: + excluded.add((int(loc[0]), int(loc[1]))) + + return [ + spec + for spec in static_entities + if (int(spec.position[0]), int(spec.position[1])) not in excluded + ] diff --git a/til-26-ae-repo/til-26-ae/til_environment/bomberman_config.yaml b/til-26-ae-repo/til-26-ae/til_environment/bomberman_config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2bde5e281009ccb40d98747f3568432f82627f27 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/bomberman_config.yaml @@ -0,0 +1,77 @@ +env: + grid_size: 16 + num_teams: 6 + num_iters: 200 + novice: true + render_mode: human + tile_respawn_steps: 40 + +dynamics: + arena: + wall_prob: 1 + wall_destructible_ratio: 0.40 + mission_prob: 0.30 + recon_prob: 0.40 + resource_prob: 0.30 + + vision: + left: 2 + right: 2 + behind: 2 + ahead: 4 + +entities: + agent: + health: 60.0 + max_health: 60.0 + freeze_turns: 3 + + base: + health: 100 + max_health: 100 + vision_radius: 3 + + bomb: + attack: 20.0 + blast_radius: 2 + timer: 3 + + mission: + reward_value: 5.0 + difficulty: 1.0 + + recon: + reward_value: 1.0 + + resource: + amount: 0.5 + +resources: + bomb_cost: 1.5 + base_resource_rate: 0.1 + starting_bombs: 3 + starting_resources: 0.0 + max_team_resources: 100.0 + max_team_bombs: 50 # how do you even + +renderer: + window_size: 768 + debug: false + render_fps: 8 + replay_dir: null + +rewards: + agent_collide_wall: 0 + agent_collide_agent: 0 + collect_mission: 5.0 + collect_recon: 1.0 + collect_resource: 2.0 + attack_damage: 1.0 + attack_kill: 30.0 + destroy_wall: 0 + destroy_enemy_base: 50.0 + own_base_destroyed: -50.0 + step_penalty: 0 + stationary_penalty: 0 + invalid_action: 0 + truncation: 0.0 diff --git a/til-26-ae-repo/til-26-ae/til_environment/bomberman_env.py b/til-26-ae-repo/til-26-ae/til_environment/bomberman_env.py new file mode 100644 index 0000000000000000000000000000000000000000..06451cf63c0878e7bc36ac6f89b01c4f6c449fb1 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/bomberman_env.py @@ -0,0 +1,373 @@ +""" +bomberman_env.py - Thin AECEnv wrapper for the TIL Bomberman. + +Top-level API class. Inherits from PettingZoo's ``AECEnv`` and delegates all +game logic to ``Dynamics`` and rendering to ``Renderer``. +""" + +from __future__ import annotations + +import functools +import logging +from functools import partial +from pathlib import Path + +import gymnasium +import numpy as np +from gymnasium.spaces import Box, Dict, Discrete +from omegaconf import DictConfig +from pettingzoo import AECEnv +from pettingzoo.utils import AgentSelector, wrappers +from pettingzoo.utils.conversions import parallel_wrapper_fn +from pettingzoo.utils.env import ActionType, AgentID, ObsType +from pettingzoo.utils.wrappers.base import BaseWrapper +from supersuit import frame_stack_v2 + +from til_environment.actions import Action, NUM_ACTIONS_V2 +from til_environment.config import ( + default_config, + load_config, + viewcone_tuple, +) +from til_environment.dynamics import Dynamics +from til_environment.entities import Agent +from til_environment.flatten_dict import FlattenDictWrapper +from til_environment.observation import NUM_CHANNELS +from til_environment.renderer import Renderer +from til_environment.types import Direction + +logger = logging.getLogger(__name__) + +def basic_env( + cfg: DictConfig | str | Path | None = None, + env_wrappers: list[BaseWrapper] | None = None, + **kwargs, +): + if cfg is None: + resolved = default_config() + elif isinstance(cfg, (str, Path)): + resolved = load_config(cfg) + else: + resolved = cfg + + environment = Bomberman(resolved, **kwargs) + if env_wrappers is None: + env_wrappers = [ + FlattenDictWrapper, + partial(frame_stack_v2, stack_size=4, stack_dim=-1), + ] + for wrapper in env_wrappers: + environment = wrapper(environment) + environment = wrappers.AssertOutOfBoundsWrapper(environment) + environment = wrappers.OrderEnforcingWrapper(environment) + return environment + +parallel_basic_env = parallel_wrapper_fn(basic_env) + + +class Bomberman(AECEnv[AgentID, ObsType, ActionType]): + + metadata = { + "render_modes": ["human", "rgb_array"], + "name": "til_bomberman", + "is_parallelizable": True, + } + + def __init__(self, cfg: DictConfig | None = None) -> None: + super().__init__() + + if cfg is None: + cfg = default_config() + self.cfg = cfg + + self.grid_size: int = int(cfg.env.grid_size) + self.num_teams: int = int(cfg.env.num_teams) + self.num_iters: int = int(cfg.env.num_iters) + + self.viewcone = viewcone_tuple(cfg.dynamics.vision) + self.viewcone_width = self.viewcone[0] + self.viewcone[1] + 1 + self.viewcone_length = self.viewcone[2] + self.viewcone[3] + 1 + + self.possible_agents = [f"agent_{i}" for i in range(self.num_teams)] + + render_mode = cfg.env.render_mode + replay_dir = cfg.renderer.replay_dir or None + if replay_dir is not None and render_mode is None: + render_mode = "rgb_array" + assert render_mode is None or render_mode in self.metadata["render_modes"] + self.render_mode = render_mode + + self.metadata["render_fps"] = int(cfg.renderer.render_fps) + + self.dynamics = Dynamics(cfg) + + self.renderer = Renderer( + grid_size=self.grid_size, + window_size=int(cfg.renderer.window_size), + render_mode=render_mode, + debug=bool(cfg.renderer.debug), + viewcone_shape=(self.viewcone_length, self.viewcone_width), + viewcone=self.viewcone, + replay_dir=replay_dir, + render_fps=int(cfg.renderer.render_fps), + num_teams=self.num_teams, + ) + + self.num_moves: int = 0 + self._agent_actions: dict[AgentID, int] = {} + + @functools.lru_cache(maxsize=None) + def observation_space(self, agent: AgentID | None = None): + # build observation space bounds from config, uhh dont change it please + # left agent in there for compat + base_r = int(self.cfg.entities.base.vision_radius) + base_side = 2 * base_r + 1 + max_freeze = int(self.cfg.entities.agent.freeze_turns) + return Dict( + { + "agent_viewcone": Box( + 0.0, + 1.0, + shape=(self.viewcone_length, self.viewcone_width, NUM_CHANNELS), + dtype=np.float32, + ), + "base_viewcone": Box( + 0.0, + 1.0, + shape=(base_side, base_side, NUM_CHANNELS), + dtype=np.float32, + ), + "direction": Discrete(len(Direction)), + "location": Box(0, self.grid_size, shape=(2,), dtype=np.uint8), + "base_location": Box(0, self.grid_size, shape=(2,), dtype=np.uint8), + "health": Box( + 0.0, float(self.cfg.entities.agent.max_health), shape=(1,), dtype=np.float32 + ), + "frozen_ticks": Discrete(max_freeze + 1), + "base_health": Box( + 0.0, float(self.cfg.entities.base.max_health), shape=(1,), dtype=np.float32 + ), + "team_resources": Box( + 0.0, float(self.cfg.resources.max_team_resources), shape=(1,), dtype=np.float32 + ), + "team_bombs": Discrete(int(self.cfg.resources.max_team_bombs) + 1), + "step": Discrete(self.num_iters + 1), + "action_mask": Box(0, 1, shape=(NUM_ACTIONS_V2,), dtype=np.uint8), + } + ) + + @functools.lru_cache(maxsize=None) + def action_space(self, agent: AgentID | None = None): + return Discrete(NUM_ACTIONS_V2) + + + def reset(self, seed: int | None = None, options: dict | None = None): + prev_stats = self._collect_episode_stats() + + agent_ids = self.dynamics.reset(seed) + self.agents = agent_ids[:] + self.agent_selector = AgentSelector(self.agents) + self.agent_selection = self.agent_selector.next() + + self.rewards = {a: 0.0 for a in self.agents} + self._cumulative_rewards = {a: 0.0 for a in self.agents} + self.terminations = {a: False for a in self.agents} + self.truncations = {a: False for a in self.agents} + self.infos = {a: {} for a in self.agents} + self.observations = {a: self.observe(a) for a in self.agents} + self._agent_actions = {} + self.num_moves = 0 + + prev_suffix = (options or {}).get("replay_suffix") + self.renderer.start_episode( + prev_suffix=prev_suffix, + prev_episode_stats=prev_stats, + ) + if self.render_mode in self.metadata["render_modes"]: + self.render() + + def _collect_episode_stats(self) -> dict | None: + if not getattr(self, "agents", None): + return None + + cumulative = dict(getattr(self, "_cumulative_rewards", {})) + agent_team = {} + team_rewards: dict[int, float] = {} + for agent_id in self.agents: + try: + agent = self.dynamics.registry.get(agent_id) + except Exception: + continue + team = int(getattr(agent, "team", -1)) + agent_team[agent_id] = team + team_rewards[team] = team_rewards.get(team, 0.0) + float( + cumulative.get(agent_id, 0.0) + ) + + return { + "num_moves": int(getattr(self, "num_moves", 0)), + "num_teams": int(self.num_teams), + "agent_team": agent_team, + "agent_cumulative_rewards": {k: float(v) for k, v in cumulative.items()}, + "team_cumulative_rewards": {str(k): float(v) for k, v in team_rewards.items()}, + "terminations": dict(getattr(self, "terminations", {})), + "truncations": dict(getattr(self, "truncations", {})), + } + + def observe(self, agent: AgentID): + obs = self.dynamics.observe(agent) + obs["step"] = self.num_moves + # lazily build + obs["action_mask"] = self.dynamics.action_mask.build(agent) + return obs + + def step(self, action: ActionType): + if self.agent_selector.is_first(): + self._agent_actions = {} + + if ( + self.terminations[self.agent_selection] + or self.truncations[self.agent_selection] + ): + self._was_dead_step(action) + return + + agent = self.agent_selection + self._cumulative_rewards[agent] = 0 + + self._agent_actions[agent] = int(action) + + if self.agent_selector.is_last(): + self._execute_round() + else: + self._clear_rewards() + + self.agent_selection = self.agent_selector.next() + self._accumulate_rewards() + + def _execute_round(self) -> None: + """ + run once all agents have submitted actions for this step. + + Phase order: + 1. Validate actions (mask enforcement) + 2. Place-bomb phase β€” PLACE_BOMB actions spawn bombs + 3. Movement phase β€” FORWARD/BACKWARD/LEFT/RIGHT/STAY + 4. Detonation phase β€” expired bombs produce AttackIntents + 5. Damage phase β€” defenders receive damage; frozen_ticks set + 6. Upkeep β€” bomb timers tick, resources/bombs update, + freeze cooldowns tick / respawn + 7. Termination / truncation checks + 8. Pull rewards, rebuild observations, render + """ + self.dynamics.rewards.clear_step() + + validated_actions: dict[str, int] = {} + for agent_id, action in self._agent_actions.items(): + agent_ent = self.dynamics.registry.get(agent_id) + if getattr(agent_ent, "is_frozen", False): + # stay put chill guy + validated_actions[agent_id] = int(Action.STAY) + continue + mask = self.dynamics.action_mask.build(agent_id) + if not mask[action]: + self.dynamics.rewards.award(agent_id, "invalid_action") + validated_actions[agent_id] = int(Action.STAY) + else: + validated_actions[agent_id] = action + + self.dynamics.place_bomb_phase(validated_actions) + + self.dynamics.resolve_movement_actions(validated_actions) + + intents = self.dynamics.detonation_phase() + self.dynamics.damage_phase(intents) + + self.dynamics.upkeep() + + # this shouldn't be here + for agent_id, action in validated_actions.items(): + agent_ent = self.dynamics.registry.get(agent_id) + if getattr(agent_ent, "is_frozen", False): + continue + if Action(action) == Action.STAY: + self.dynamics.rewards.award(agent_id, "stationary_penalty") + + # trunc + self.num_moves += 1 + if self.num_moves >= self.num_iters: + self.truncations = {a: True for a in self.agents} + for a in self.agents: + self.dynamics.rewards.award(a, "truncation") + + # money time + step_rewards = self.dynamics.rewards.step_rewards() + for a in self.agents: + self.rewards[a] = step_rewards.get(a, 0.0) + + for a in self.agents: + self.observations[a] = self.observe(a) + self.infos[a] = self._build_info(a) + + if self.render_mode in self.metadata["render_modes"]: + self.render() + + # ── termination ──────────────────────────────────────────────────────── + # "IMMORTALITY" - Argus MLBB + # ────────────────────────────────────────────────────────────────────── + + def _build_info(self, agent_id: str) -> dict: + agent = self.dynamics.registry.get(agent_id) + if not isinstance(agent, Agent): + return {} + bases = self.dynamics.registry.bases(agent.team) + base_dist = ( + float(np.linalg.norm(agent.position - bases[0].position, ord=1)) + if bases + else -1 + ) + return { + "health": agent.health, + "frozen_ticks": agent.frozen_ticks, + "base_distance": base_dist, + "base_health": bases[0].health if bases else 0.0, + "team_resources": self.dynamics.team_resources.get(agent.team, 0.0), + "team_bombs": self.dynamics.team_bombs.get(agent.team, 0), + } + + # ── render / close ───────────────────────────────────────────────────── + + def render( + self, + selected_agent_id: str | None = None, + respawn_overlay: "np.ndarray | None" = None, + ): + if self.render_mode is None: + gymnasium.logger.warn( + "You are calling render method without specifying any render mode." + ) + return + return self.renderer.render( + state=self.dynamics.state, + registry=self.dynamics.registry, + observations=self.observations, + rewards=self.rewards, + actions=self._agent_actions, + num_moves=self.num_moves, + agent_ids=self.agents, + selected_agent_id=selected_agent_id, + explosions=self.dynamics.last_explosions, + respawn_overlay=respawn_overlay, + ) + + def close(self, replay_suffix: str | None = None): + self.renderer.close( + final_suffix=replay_suffix, + final_episode_stats=self._collect_episode_stats(), + ) + + def finalise_current_replay(self, suffix: str | None = None) -> None: + self.renderer.finalise_current_replay(suffix) + + def state(self): + return self.dynamics.state diff --git a/til-26-ae-repo/til-26-ae/til_environment/config.py b/til-26-ae-repo/til-26-ae/til_environment/config.py new file mode 100644 index 0000000000000000000000000000000000000000..a9b0f5f0af2e73c5881256e96caf2528ee694c1f --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/config.py @@ -0,0 +1,248 @@ +""" +config.py - Hierarchical OmegaConf-based configuration for the TIL Bomberman. + +This module provides a **single source of truth** for every tuneable +parameter in the environment. + +Design +------ +The config tree mirrors the sub-system hierarchy:: + + BombermanConfig + β”œβ”€β”€ env β€” top-level game rules (grid size, teams, iterations, …) + β”œβ”€β”€ dynamics β€” physics / game-logic tunables + β”‚ β”œβ”€β”€ arena β€” maze generation + β”‚ └── vision β€” viewcone shape + β”œβ”€β”€ entities β€” per-entity-type defaults + β”‚ β”œβ”€β”€ agent + β”‚ β”œβ”€β”€ base + β”‚ β”œβ”€β”€ bomb + β”‚ β”œβ”€β”€ mission + β”‚ β”œβ”€β”€ recon + β”‚ └── resource + β”œβ”€β”€ resources β€” per-team resource / bomb economy (ratios) + β”œβ”€β”€ renderer β€” display settings + └── rewards β€” reward shaping values +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from pathlib import Path + +from omegaconf import OmegaConf, DictConfig + + +# ═══════════════════════════════════════════════════════════════════════════ +# env β€” top-level game rules +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class EnvConfig: + """Top-level environment parameters.""" + + grid_size: int = 16 + num_teams: int = 6 + num_iters: int = 200 + novice: bool = False + render_mode: str | None = None + tile_respawn_steps: int = 40 + + +# ═══════════════════════════════════════════════════════════════════════════ +# dynamics β€” physics / game-logic tunables +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class ArenaConfig: + """Maze generation parameters.""" + + wall_prob: float = 1.0 + wall_destructible_ratio: float = 0.4 + mission_prob: float = 0.30 + recon_prob: float = 0.40 + resource_prob: float = 0.30 + + +@dataclass +class VisionConfig: + """Viewcone shape definition.""" + + left: int = 2 + right: int = 2 + behind: int = 2 + ahead: int = 4 + + +@dataclass +class DynamicsConfig: + """Game-logic tunables passed to the ``Dynamics`` engine.""" + + arena: ArenaConfig = field(default_factory=ArenaConfig) + vision: VisionConfig = field(default_factory=VisionConfig) + + +# ═══════════════════════════════════════════════════════════════════════════ +# entities β€” per-type default attribute values +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class AgentEntityConfig: + """Default attributes for newly created Agents.""" + + health: float = 60 + max_health: float = 60 + freeze_turns: int = 3 + + +@dataclass +class BaseEntityConfig: + """Default attributes for newly created Bases.""" + + health: float = 100 + max_health: float = 100 + vision_radius: int = 3 + + +@dataclass +class BombEntityConfig: + """Default attributes for Bomb entities.""" + + attack: float = 20.0 + blast_radius: int = 2 + timer: int = 4 + + +@dataclass +class MissionEntityConfig: + """Default attributes for Mission entities.""" + + reward_value: float = 5.0 + difficulty: float = 1.0 + + +@dataclass +class ReconEntityConfig: + """Default attributes for Recon entities.""" + + reward_value: float = 1.0 + + +@dataclass +class ResourceEntityConfig: + """Default attributes for Resource tile entities (amount is a ratio).""" + + amount: float = 0.5 + + +@dataclass +class EntitiesConfig: + """Collected entity defaults β€” one sub-config per entity type.""" + + agent: AgentEntityConfig = field(default_factory=AgentEntityConfig) + base: BaseEntityConfig = field(default_factory=BaseEntityConfig) + bomb: BombEntityConfig = field(default_factory=BombEntityConfig) + mission: MissionEntityConfig = field(default_factory=MissionEntityConfig) + recon: ReconEntityConfig = field(default_factory=ReconEntityConfig) + resource: ResourceEntityConfig = field(default_factory=ResourceEntityConfig) + + +# ═══════════════════════════════════════════════════════════════════════════ +# resources β€” per-team resource / bomb economy +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class ResourcesConfig: + """Per-team resource economy expressed as ratios. + + All values are floats; ``bomb_cost`` acts as the unit. Resources + accumulate in a shared team pool and auto-convert into bombs whenever + the pool reaches ``bomb_cost``. + + ``max_team_resources`` and ``max_team_bombs`` are used as the upper + bounds for the observation space declarations. + """ + + bomb_cost: float = 1.5 + base_resource_rate: float = 0.1 + starting_bombs: int = 3 + starting_resources: float = 0.0 + max_team_resources: float = 100.0 + max_team_bombs: int = 50 + + +# ═══════════════════════════════════════════════════════════════════════════ +# renderer β€” display settings +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class RendererConfig: + """Settings for the pygame renderer.""" + + window_size: int = 768 + debug: bool = False + render_fps: int = 5 + replay_dir: str | None = None + + +# ═══════════════════════════════════════════════════════════════════════════ +# rewards β€” reward shaping values +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class RewardsConfig: + """Every reward-producing event and its default value.""" + + agent_collide_wall: float = 0 + agent_collide_agent: float = 0 + collect_mission: float = 5.0 + collect_recon: float = 1.0 + collect_resource: float = 2.0 + attack_damage: float = 1.0 + attack_kill: float = 15.0 + destroy_wall: float = 0 + destroy_enemy_base: float = 50.0 + own_base_destroyed: float = -50.0 + step_penalty: float = 0 + stationary_penalty: float = 0 + invalid_action: float = 0 + truncation: float = 0 + + +# ═══════════════════════════════════════════════════════════════════════════ +# Root config +# ═══════════════════════════════════════════════════════════════════════════ +@dataclass +class BombermanConfig: + """Root configuration object.""" + + env: EnvConfig = field(default_factory=EnvConfig) + dynamics: DynamicsConfig = field(default_factory=DynamicsConfig) + entities: EntitiesConfig = field(default_factory=EntitiesConfig) + resources: ResourcesConfig = field(default_factory=ResourcesConfig) + renderer: RendererConfig = field(default_factory=RendererConfig) + rewards: RewardsConfig = field(default_factory=RewardsConfig) + + +# ═══════════════════════════════════════════════════════════════════════════ +# Factories +# ═══════════════════════════════════════════════════════════════════════════ + +_STRUCTURED = OmegaConf.structured(BombermanConfig) + + +def default_config() -> DictConfig: + """Return a fresh ``BombermanConfig`` as an OmegaConf DictConfig.""" + return OmegaConf.structured(BombermanConfig) + + +def load_config(path: str | Path) -> DictConfig: + """Load a YAML file and merge it onto the structured defaults.""" + schema = OmegaConf.structured(BombermanConfig) + user = OmegaConf.load(path) + merged = OmegaConf.merge(schema, user) + return merged + + +def save_config(cfg: DictConfig, path: str | Path) -> None: + """Serialise a config to YAML on disk.""" + Path(path).write_text(OmegaConf.to_yaml(cfg)) + + +def viewcone_tuple(cfg: VisionConfig | DictConfig) -> tuple[int, int, int, int]: + """Return the ``(left, right, behind, ahead)`` tuple from a VisionConfig.""" + return (int(cfg.left), int(cfg.right), int(cfg.behind), int(cfg.ahead)) diff --git a/til-26-ae-repo/til-26-ae/til_environment/docs/ARCHITECTURE.md b/til-26-ae-repo/til-26-ae/til_environment/docs/ARCHITECTURE.md new file mode 100644 index 0000000000000000000000000000000000000000..67bdb1777a945aec91db55e31b1cf83ba320a2f9 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/docs/ARCHITECTURE.md @@ -0,0 +1,446 @@ +# TIL Bomberman v2 β€” Architecture + +## Overview + +The v2 environment refactors the original monolithic `gridworld.py` into a +layered architecture with clear separation of concerns. **No original files +were modified or deleted** β€” v1 continues to work as-is. + +``` +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” +β”‚ gridworld_v2.py β”‚ ← Tier A: AECEnv API +β”‚ Bomberman(AECEnv) β”‚ +β”‚ Only implements: reset, step, observe, β”‚ +β”‚ render, close, observation_space, action_space β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ + β”‚ β”‚ + β–Ό β–Ό +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” +β”‚ dynamics.py β”‚ β”‚ renderer.py β”‚ β”‚ config.py β”‚ +β”‚ β”‚ β”‚ β”‚ β”‚ β”‚ ← Tier C +β”‚ Dynamics(cfg) β”‚ β”‚ Renderer β”‚ β”‚ BombermanConfig β”‚ +β”‚ β”œ VisionSystem β”‚ β”‚ (all pygame β”‚ β”‚ β”œ EnvConfig β”‚ +β”‚ β”” (composes arena, β”‚ β”‚ drawing) β”‚ β”‚ β”œ DynamicsConfig β”‚ +β”‚ actions, obs) β”‚ β”‚ β”‚ β”‚ β”œ EntitiesConfig β”‚ +β””β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”€β”€β”€β”€β”¬β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β”‚ β”œ RendererConfig β”‚ + β”‚ β”‚ β”‚ β”‚ β”œ RewardsConfig β”‚ + β–Ό β–Ό β–Ό β”‚ β”” ObsSpaceConfig β”‚ +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ +β”‚arena.pyβ”‚β”‚actions.pyβ”‚β”‚observation.pyβ”‚ +β”‚ β”‚β”‚ β”‚β”‚ β”‚ ← Tier C: Utility systems +β”‚ Arena β”‚β”‚ Action β”‚β”‚ ViewChannel β”‚ +β”‚ Gen. β”‚β”‚ BaseAct. β”‚β”‚ 18-ch build β”‚ +β”‚ β”‚β”‚ Masks β”‚β”‚ β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”˜β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ + β”‚ + β–Ό +β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” β”Œβ”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β” +β”‚ entities/ β”‚ β”‚ types_v2.py β”‚ ← Tier B: Data / domain model +β”‚ (see ENTITY_ β”‚ β”‚ β”‚ +β”‚ REFACTOR.md) β”‚ β”‚ RewardEvent β”‚ +β”‚ β”‚ β”‚ ObservationV2 β”‚ +β”‚ Entity (base) β”‚ β”‚ TeamResult β”‚ +β”‚ β”œ Agent β”‚ β”‚ (+ re-exports β”‚ +β”‚ β”œ Base β”‚ β”‚ from types.py) β”‚ +β”‚ β”œ Beacon β”‚ β”‚ β”‚ +β”‚ β”œ Scout β”‚ β”‚ β”‚ +β”‚ β”œ Mission β”‚ β”‚ β”‚ +β”‚ β”œ Recon β”‚ β”‚ β”‚ +β”‚ β”” PowerUp β”‚ β”‚ β”‚ +β”‚ β”‚ β”‚ β”‚ +β”‚ Geometry: β”‚ β”‚ β”‚ +β”‚ AttackType β”‚ β”‚ β”‚ +β”‚ VisionType β”‚ β”‚ β”‚ +β”‚ β”‚ β”‚ β”‚ +β”‚ Trait protocols: β”‚ β”‚ β”‚ +β”‚ Attacker β†’ Agent β”‚ β”‚ β”‚ +β”‚ Defender β†’ Agent β”‚ β”‚ β”‚ +β”‚ Base β”‚ β”‚ β”‚ +β”‚ Beacon β”‚ β”‚ β”‚ +β”‚ Collector β†’ Base β”‚ β”‚ β”‚ +β”‚ Beacon β”‚ β”‚ β”‚ +β”‚ Vision β†’ Agent β”‚ β”‚ β”‚ +β”‚ Base β”‚ β”‚ β”‚ +β”‚ Beacon β”‚ β”‚ β”‚ +β”‚ Scout β”‚ β”‚ β”‚ +β”‚ Healer β†’ Base β”‚ β”‚ β”‚ +β”‚ Beacon β”‚ β”‚ β”‚ +β”‚ β”‚ β”‚ β”‚ +β”‚ EntityRegistry β”‚ β”‚ β”‚ +β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ β””β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”€β”˜ +``` + +--- + +## Configuration β€” `config.py` + `default_config.yaml` + +**Every tuneable parameter** is declared in structured dataclasses and loaded +from YAML via OmegaConf. A single `DictConfig` flows top-down: + +``` +BombermanConfig +β”œβ”€β”€ env grid_size, num_teams, agents_per_team, num_iters, novice, render_mode +β”œβ”€β”€ dynamics +β”‚ β”œβ”€β”€ arena wall_prob, mission_prob, recon_prob, powerup_prob +β”‚ └── vision left, right, behind, ahead +β”œβ”€β”€ entities +β”‚ β”œβ”€β”€ agent health, max_health, attack, defense +β”‚ β”œβ”€β”€ base health, max_health, resource_rate, heal_rate, vision_radius (β†’ vision_type) +β”‚ β”œβ”€β”€ beacon vision_radius (β†’ vision_type), heal_rate, heal_radius, manufacture_cost +β”‚ β”œβ”€β”€ scout velocity, vision_radius (β†’ vision_type), manufacture_cost +β”‚ β”œβ”€β”€ mission reward_value, difficulty +β”‚ └── powerup duration, strength +β”œβ”€β”€ renderer window_size, debug, render_fps +β”œβ”€β”€ rewards 14 reward-shaping values (collisions, kills, collection, penalties, …) +└── obs_space max_agent_health, max_base_health, max_base_resources, max_inventory, … +``` + +| Function | Purpose | +|----------|---------| +| `default_config()` | Fresh `DictConfig` with all dataclass defaults | +| `load_config(path)` | Merge a YAML file onto structured defaults (catches typos) | +| `save_config(cfg, path)` | Serialise config to YAML | +| `viewcone_tuple(cfg)` | Extract `(left, right, behind, ahead)` tuple | + +`Bomberman.__init__` accepts a `DictConfig` and passes it to `Dynamics(cfg)`. +Entity creation in `Dynamics.reset()` reads from `cfg.entities.*`. +Rewards in `Bomberman._apply_*_rewards()` read from `cfg.rewards.*`. + +--- + +## Tier A β€” `gridworld_v2.py` β†’ `Bomberman` + +**Responsibility:** PettingZoo AEC contract β€” nothing else. + +| Method | What it does | +|--------|-------------| +| `__init__(cfg)` | Stores config, creates `Dynamics(cfg)` and `Renderer(…)` | +| `reset()` | Seeds RNG, calls `Dynamics.reset()`, sets up agent selectors | +| `step(action)` | Buffers per-agent dict actions, calls `_execute_round()` when all agents have acted | +| `observe(agent)` | Delegates to `Dynamics.observe()`, stamps current step count + action masks | +| `render()` | Delegates to `Renderer.render()` | +| `close()` | Delegates to `Renderer.close()` | +| `observation_space()` | Returns `gymnasium.spaces.Dict` with bounds from `cfg.obs_space` | +| `action_space()` | Returns `Dict({"agent": Discrete(7), "base": Discrete(3)})` | + +The class owns **no** movement logic, collision math, or pygame calls. + +**Factory functions:** +- `env_v2(cfg)` β€” wraps `Bomberman` with `FlattenDictWrapper`, `frame_stack_v2`, bounds-check, and order-enforcing wrappers. +- `parallel_env_v2` β€” parallel conversion of `env_v2`. + +--- + +## Tier B β€” Entity classes (`entities/`, `types_v2.py`) + +> **Note:** `entities.py` has been split into the `entities/` package. +> See `ENTITY_REFACTOR.md` for the full rationale and migration record. +> All names remain importable from `til_environment.entities` via the +> package `__init__.py` re-export. + +### Entity hierarchy + +All game objects inherit from `Entity` and explicitly declare each protocol they satisfy as a base class. + +**Dynamic entities** β€” persistent mutable state, can be damaged / moved / craft effects: + +| Class | Key attributes | Traits | +|-------|---------------|--------| +| **Entity** | `entity_id`, `team`, `position`, `status` | β€” | Abstract base; owns `alive`, `destroy()`, distance helpers | +| **Agent** | `health`, `max_health`, `attack`, `defense`, `experience`, `direction`, `active_powerups`, `attack_type`, `vision_type` | Attacker, Defender, Vision, Experience | Mobile unit. Collects missions + recon, fights enemies. Uses directional viewcone in `VisionSystem`; `vision_type` adds optional radius-based supplement | +| **Base** | `health`, `max_health`, `resources`, `resource_rate`, `heal_rate`, `heal_radius`, `vision_type` | Defender, Collector, Vision, Healer | Stationary. Absorbs attacks, gathers resources, heals allies, reveals area. Loss condition if destroyed | +| **Beacon** | `health`, `max_health`, `vision_type`, `heal_rate`, `heal_radius`, `manufacture_cost` | Defender, Collector, Vision, Healer | Placed by agents. Can be destroyed; provides vision + healing aura | +| **Scout** | `direction`, `velocity`, `vision_type`, `manufacture_cost` | Vision | Mobile recon unit launched from Base. Destroyed on wall hit | + +**Static entities** β€” spawned once, no mutable game state, consumed on agent contact: + +| Class | Key attributes | Notes | +|-------|---------------|-------| +| **Mission** | `reward_value`, `difficulty` | Team-neutral. Reward on collection | +| **Recon** | `reward_value` | Team-neutral. Reward on collection | +| **PowerUp** | `powerup_type`, `duration`, `strength` | Team-neutral. Grants buff. Can co-exist with Mission/Recon on same tile | + +### Pluggable geometry types + +Attack and vision geometry are decoupled from entity classes via callable +protocols. Each entity holds a pluggable instance; `Dynamics` never needs to +know which implementation is active. + +**Attack types** β€” `(position, direction) β†’ list[ndarray]`: + +| Class | Cells returned | Direction-aware? | +|-------|---------------|------------------| +| `FrontArcAttack` | 5-cell front arc: directly ahead + 2 front diagonals + 2 flanks | Yes | +| `AllAroundAttack` | All 8 Moore-neighbourhood tiles | No | + +**Vision types** β€” `(position, direction) β†’ list[tuple[int,int]]`; also expose `.radius` for `build_radius_view`: + +| Class | Cells returned | Direction-aware? | +|-------|---------------|------------------| +| `SquareVision(n)` | `(2n+1)Γ—(2n+1)` square centred on entity | No | +| `SkewVision(n, m)` | Same base square + `m` extra tile-depths in facing direction | Yes | + +### Trait protocols + +Structural protocols enable polymorphic dispatch without inheritance coupling. +Each concrete entity class **explicitly inherits** the protocols it satisfies. + +Because `Attacker`, `Defender`, etc. are *subclasses* of `Protocol` (not +`Protocol` itself), they appear in each implementor’s `__mro__` and are +keyed in `EntityRegistry.type_index`. This means `registry.defenders()` calls +`_alive_of_type(Defender)` directly β€” no need to enumerate concrete types. + +| Protocol | Key members | Implementors | +|----------|------------|--------------| +| `Attacker` | `attack_type: AttackType`, `attack_power: float`, `get_attack_cells()` | Agent | +| `Defender` | `health`, `receive_damage()` | Agent, Base, Beacon | +| `Collector` | `collect_resources()` | Base, Beacon | +| `Vision` | `vision_type: VisionType`, `get_visible_cells()` | Agent, Base, Beacon, Scout | +| `Healer` | `heal_rate`, `heal_radius` | Base, Beacon | + +### EntityRegistry + +A flat `dict[str, Entity]` store with four complementary indexes: + +- `pos_index` β€” `list[list[set[str]]]` pre-allocated `grid_sizeΓ—grid_size`; direct `[x][y]` access, O(1) +- `status_index` β€” `EntityStatus β†’ set[entity_id]` +- `team_index` β€” `team β†’ set[entity_id]` +- `type_index` β€” `type β†’ set[entity_id]`; keyed by **every class in the MRO** except `object`, `Generic`, `Protocol` + +Typed accessor methods fall into two groups: +- **Concrete-type accessors**: `agents(team?)`, `bases(team?)`, `beacons(team?)`, `scouts(team?)`, `missions()`, `recons()`, `powerups()` +- **Protocol accessors**: `attackers(team?)`, `defenders(team?)`, `collectors(team?)`, `vision_providers(team?)`, `healers(team?)` β€” each calls `_alive_of_type(TheProtocol)` directly + +A **Query builder** (`registry.query()`) supports composable, lazy multi-criteria +lookups across type, team, status, and position: + +```python +registry.query().type(Defender).team(0).status(EntityStatus.ACTIVE).all() +``` + +### types_v2.py + +| Type | Purpose | +|------|---------| +| `RewardEvent` | 16 canonical reward event names | +| `ObservationV2` | TypedDict specifying the full observation dict shape | +| `TeamResult` | IN_PROGRESS / WIN / LOSS / DRAW enum | + +--- + +## Tier C β€” Utility systems + +### `dynamics.py` β†’ `Dynamics` + +Owns **all mutable state transitions**. Accepts a `DictConfig` and extracts +all parameters from it. + +| Sub-component | What it does | +|--------------|-------------| +| `VisionSystem` | Line-of-sight (LOS) checks, viewcone construction, team-wide visible area | +| `Dynamics` (main) | 10-phase round execution: movement, combat, crafting, scouting, collection, upkeep, termination | + +#### State grid encoding (`_state`) + +`_state` is a `(grid_size, grid_size) uint8` array that encodes **walls only**: + +``` +Bit β”‚ Meaning β”‚ Direction.value +──────┼─────────────────────────────────┼──────────────── + 0 β”‚ Wall on RIGHT edge of tile β”‚ Direction.RIGHT = 0 + 1 β”‚ Wall on BOTTOM edge of tile β”‚ Direction.DOWN = 1 + 2 β”‚ Wall on LEFT edge of tile β”‚ Direction.LEFT = 2 + 3 β”‚ Wall on TOP edge of tile β”‚ Direction.UP = 3 + 4–7 β”‚ Always zero +``` + +The bit index is always `Direction.value` for the corresponding facing direction. +`convert_tile_to_edge` (v1 helper, unmodified) writes walls into bits 4–7; +`ArenaGenerator.generate_walls` applies `wall_grid >>= 4` immediately after to +shift them to bits 0–3. + +Wall mutation is provided by `Dynamics.destroy_wall(x, y, direction)` and +`Dynamics.add_wall(x, y, direction)`. Both methods keep `_state` and +`self.walls` (the LOS edge-set) in sync atomically. + +**Static entity presence** (Mission, Recon, PowerUp) is tracked **exclusively** +in the `EntityRegistry`. There is no redundant tile-type bitmask in `_state`. +This means: +- A tile can hold a Mission **and** a PowerUp simultaneously. +- Picking up an entity is just `entity.destroy()` β€” no grid mutation needed. +- `_handle_tile_pickup` queries the registry, not the state array. + +Entity creation in `reset()` reads from `cfg.entities.agent`, `cfg.entities.base`, +and from `ArenaResult.static_entities` (list of `StaticEntitySpec`). +Craft phase reads from `cfg.entities.scout`, `cfg.entities.beacon`. + +Key design rule: **Dynamics never touches pygame.** It only mutates the +numpy state grid + EntityRegistry. + +### `arena.py` β†’ `ArenaGenerator` + +Generation is split into **two distinct stages** for efficiency and flexibility: + +#### Stage 1 β€” Wall generation (`generate_walls`, cached) + +| Method | What it does | +|--------|-------------| +| `generate_walls(rng, seed)` | Runs Prims/DungeonRooms maze, knocks down walls, builds `WallResult`. **Cached** β€” only rerun when seed changes. | +| `_build_wall_set(wall_grid)` | Converts wall grid to `set[edge]` for O(1) LOS checks | + +The **wall grid** is a `uint8` array with bits 0–3 encoding the four wall +directions (aligned with `Direction.value`: RIGHT=0, BOTTOM=1, LEFT=2, TOP=3). +Bits 4–7 are always zero. `convert_tile_to_edge` (v1 helper) writes into bits +4–7 using the v1 `Wall` enum; `generate_walls` right-shifts by 4 immediately +after to land in bits 0–3. + +The cached `WallResult` is reused for consecutive episodes on the same seed, +making `Dynamics.reset()` fast without regenerating the expensive maze. + +#### Stage 2 β€” Episode generation (`generate_episode`, always fresh) + +| Method | What it does | +|--------|-------------| +| `generate_episode(rng, seed, …)` | Calls cached `generate_walls` + `generate_static_layer` + spread starts | +| `generate_static_layer(rng, wall_grid)` | Scatters Mission / Recon / PowerUp entities per-tile with configurable probabilities | +| `_spread_starting_positions()` | Places bases and agents with maximum separation | + +**Static entity rules** (all independent per non-wall tile): +- `mission_prob` β†’ `"mission"` spec +- `recon_prob` β†’ `"recon"` spec (mutually exclusive with mission in same roll, drawn from a multinomial) +- `powerup_prob` β†’ `"powerup"` spec (second independent Bernoulli roll β€” can co-exist with a mission or recon) + +Returns an `ArenaResult` containing the wall grid, walls set, and a list of +`StaticEntitySpec(kind, position)` that `Dynamics.reset()` uses to instantiate +entities into the `EntityRegistry`. + +#### Key data types + +| Type | Purpose | +|------|---------| +| `WallResult` | `{ wall_grid, walls, seed }` β€” cached output of wall generation | +| `StaticEntitySpec` | `{ kind: "mission"/"recon"/"powerup", position }` β€” one spec per entity to spawn | +| `ArenaResult` | Full episode setup: wall grid + walls + static entity specs + start positions | + +### `actions.py` β†’ `Action`, `BaseAction`, masks + +Defines the expanded action vocabulary and per-step mask builders: + +| Class / Enum | Values | +|-------------|--------| +| `Action` | FORWARD, BACKWARD, LEFT, RIGHT, STAY, ATTACK, ITEM | +| `BaseAction` | DO_NOTHING, CRAFT_SCOUT, CRAFT_BEACON | +| `ActionMask` | Builds per-agent mask (e.g. ATTACK only if adjacent enemy) | +| `BaseActionMask` | Builds per-agent base-action mask (e.g. CRAFT only if resources β‰₯ cost) | + +Actions are grouped into `ActionGroup` categories (MOVEMENT, COMBAT, UTILITY) +for mutual-exclusion validation. + +### `observation.py` β†’ multi-channel viewcone builders + +Replaces v1's bitwise `uint8` encoding with sparse `float32` tensors (H Γ— W Γ— 18): + +| Function | What it builds | +|----------|---------------| +| `build_agent_viewcone()` | Directional H Γ— W Γ— C tensor for an agent's facing-relative view | +| `build_radius_view()` | Circular (2R+1)Β² Γ— C tensor for bases, beacons, scouts | +| `populate_channels()` | Shared core: stamps wall, tile, and entity data into a view | + +18 channels defined by `ViewChannel` IntEnum: VISIBLE, 4Γ— walls, 3Γ— tile types, +2Γ— ally/enemy for agents/bases/beacons/scouts, MISSION_ITEM, POWERUP_ITEM. + +### `renderer.py` β†’ `Renderer` + +Owns **all pygame drawing**: + +- Lazy display initialisation (only creates a window on first `render()` call) +- Draws tiles, walls, grid lines from the numpy state array +- Draws entities (agents with health bars, bases, beacons, scouts, missions, powerups) + via the EntityRegistry +- Debug panel showing per-agent viewcone observations, rewards, and actions + +Key design rule: **Renderer never mutates game state.** It only reads. + +--- + +## Game Flow (one episode) + +``` +Bomberman.reset(seed) + β””β†’ Dynamics.reset(seed) + β”œβ†’ ArenaGenerator.generate() # maze + tiles + starting positions + β””β†’ populate EntityRegistry # Agent, Base, Mission from cfg.entities.* + +for each step: + Bomberman.step({"agent": int, "base": int}) + β”œβ†’ buffer dict action for current agent + β””β†’ (on last agent) _execute_round() + β”‚ + β”‚ Phase 0: Validate actions against masks + β”‚ Phase 1: Dynamics.resolve_movement_actions() β€” move + collisions + pickups + deposits + β”‚ Phase 2: Dynamics.attack_phase() β€” collect attack intents + β”‚ Phase 3: Dynamics.damage_phase() β€” apply damage, destroy at 0 HP + β”‚ Phase 4: Dynamics.craft_phase() β€” base manufactures scouts / beacons + β”‚ Phase 5: Dynamics.scout_phase() β€” advance scouts, destroy on wall hit + β”‚ Phase 6: Dynamics.collect_phase() β€” bases gather passive resources + β”‚ Phase 7: Dynamics.upkeep() β€” beacon healing, powerup timers, mission processing + β”‚ Phase 8: Step / idle penalties + β”‚ Phase 9: Dynamics.check_termination() β€” base/agent destruction + β”‚ Phase 10: Rebuild observations + render + β”‚ + β””β†’ rewards applied from cfg.rewards.* at each phase +``` + +--- + +## File Inventory + +| File | Lines | Status | Description | +|------|-------|--------|-------------| +| `gridworld.py` | 863 | **Unchanged** (v1) | Original monolithic environment | +| `types.py` | 206 | **Unchanged** (v1) | Direction, Action, Tile, Wall, Player, RewardNames | +| `helpers.py` | 145 | **Unchanged** | Math/vision helper functions | +| `flatten_dict.py` | 24 | **Unchanged** | PettingZoo wrapper | +| `__init__.py` | 1 | **Unchanged** | Package imports (v1) | +| `config.py` | 305 | **v2** | OmegaConf structured config dataclasses + load/save | +| `default_config.yaml` | β€” | **v2** | Reference YAML with all defaults | +| `dynamics.py` | 905 | **v2** | Dynamics(cfg), VisionSystem, all game logic | +| `arena.py` | 580 | **v2** | ArenaGenerator, ArenaResult, two-stage generation | +| `actions.py` | 300 | **v2** | Action, BaseAction, ActionMask, BaseActionMask | +| `observation.py` | 380 | **v2** | ViewChannel, multi-channel viewcone builders | +| `renderer.py` | 614 | **v2** | Renderer (pygame) | +| `gridworld_v2.py` | 480 | **v2** | Bomberman(AECEnv) v2 | +| `types_v2.py` | 120 | **v2** | RewardEvent, ObservationV2, TeamResult | +| `test.py` | 271 | **v2** | Interactive keyboard test harness | +| **`entities/` package** | | **v2** | Entity hierarchy split from the original monolithic `entities.py` | +| `entities/__init__.py` | 74 | **v2** | Flat re-export of every public name | +| `entities/base.py` | 89 | **v2** | Entity base class, EntityStatus | +| `entities/protocols.py` | 91 | **v2** | Trait protocols: Attacker, Defender, Collector, Vision, Healer, Product, Experience | +| `entities/geometry.py` | 207 | **v2** | AttackType, VisionType, FrontArcAttack, AllAroundAttack, SquareVision, SkewVision | +| `entities/dynamic.py` | 234 | **v2** | Agent, Base, Beacon, Scout | +| `entities/static.py` | 128 | **v2** | Mission, Recon, PowerUp, PowerUpType, AttackIntent | +| `entities/registry.py` | 348 | **v2** | EntityRegistry + Query builder | +| `ENTITY_REFACTOR.md` | β€” | **v2** | Completed migration record: monolithic `entities.py` β†’ `entities/` package | + +--- + +## How to Extend + +- **New entity type**: Add a dataclass in `entities/dynamic.py` (or `entities/static.py` + for a collectible), add a config dataclass in `config.py` (+ YAML defaults), + add a draw method in `renderer.py`, handle its game logic in `dynamics.py`. + Re-export from `entities/__init__.py`. +- **New attack geometry**: Add a class to `entities/geometry.py` implementing + `AttackType`; pass it as `attack_type=` when constructing an `Agent`. +- **New vision geometry**: Add a class to `entities/geometry.py` implementing + `VisionType`; pass it as `vision_type=` when constructing any Vision entity. +- **New trait protocol**: Add to `entities/protocols.py`; inherit it in the + relevant entity class; add an accessor to `EntityRegistry` in `entities/registry.py`. +- **New reward event**: Add to `RewardsConfig` in `config.py`, add the YAML + default, wire it in `Bomberman._apply_*_rewards()`. +- **New action**: Extend `Action` or `BaseAction` in `actions.py`, update + the mask builder, handle in `Dynamics`. +- **New observation channel**: Add to `ViewChannel` in `observation.py`, + add a populate clause in `populate_channels()`. +- **Alternative renderer**: Implement the same + `render(state, registry, ...)` interface as `Renderer`. diff --git a/til-26-ae-repo/til-26-ae/til_environment/docs/ENTITY_REFACTOR.md b/til-26-ae-repo/til-26-ae/til_environment/docs/ENTITY_REFACTOR.md new file mode 100644 index 0000000000000000000000000000000000000000..c04e9c6dda935b5504da248ffae7d40b70a5823d --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/docs/ENTITY_REFACTOR.md @@ -0,0 +1,241 @@ +# Entity Refactoring β€” Migration Record + +> **Status: COMPLETE.** The `entities/` package is live. All import sites +> use `from til_environment.entities import X` and continue to work unchanged. +> This document is kept as a reference for the rationale and decisions made +> during the migration. + +--- + +## 1. Current Scope of `entities.py` + +`entities.py` is currently a single 1,040-line file that owns five distinct +conceptual layers, all bundled together: + +### 1.1 Primitive enums and value types +- `EntityStatus` β€” `ACTIVE` / `DESTROYED` lifecycle flag +- `PowerUpType` β€” catalogue of buff types +- `AttackIntent` β€” a dataclass recording a queued attack + +### 1.2 Pluggable geometry types +- `AttackType` (Protocol) β€” callable: `(position, direction) β†’ list[ndarray]` +- `_rotate()` β€” shared rotation helper +- `FrontArcAttack`, `AllAroundAttack` β€” two concrete attack geometries +- `FRONT_ARC`, `ALL_AROUND` β€” singleton instances +- `VisionType` (Protocol) β€” callable: `(position, direction) β†’ list[tuple]` +- `SquareVision(n)`, `SkewVision(n, m)` β€” two concrete vision geometries + +### 1.3 Trait protocols +- `Attacker`, `Defender`, `Collector`, `Vision`, `Healer` +- `Product`, `Experience` β€” secondary protocols +- All are `@runtime_checkable` subclasses of `Protocol`; because they appear + in the MRO of their implementors, `EntityRegistry.type_index` can key on them + directly β€” no need to spell out concrete implementors at query sites. + +### 1.4 Entity classes +- `Entity` β€” abstract base with `entity_id`, `team`, `position`, `status`, registry + back-ref, `alive`, `destroy()`, distance helpers +- **Dynamic entities** (have mutable state, live the whole episode, can be damaged, + moved, or produce effects): + - `Agent` β€” Attacker, Defender, Vision, Experience + - `Base` β€” Defender, Collector, Vision, Healer + - `Beacon` β€” Defender, Collector, Vision, Healer + - `Scout` β€” Vision +- **Static entities** (spawned once, consumed on contact, carry no mutable game state): + - `Mission` β€” collectible; reward on deposit + - `Recon` β€” collectible; immediate reward + - `PowerUp` β€” collectible; grants buff + +### 1.5 EntityRegistry +- 1,040-line file ends with the entire `EntityRegistry` class (~270 lines) +- Four indexes: `pos_index` (2D grid-of-sets), `status_index`, `team_index`, + `type_index` +- Protocol-aware typed accessors: `agents()`, `defenders()`, `vision_providers()`, etc. +- `type_index` is keyed by **any class in the MRO** of an entity β€” including protocol + subclasses like `Defender` and `Vision` β€” so `_alive_of_type(Defender)` works + without enumerating concrete types. + +--- + +## 2. Problems with the Current Structure + +| Problem | Detail | +|---------|--------| +| **Monolithic file** | 1,040 lines. Adding a new entity type, a new protocol, or a new geometry means editing the same file as the registry and the enums. | +| **Mixed abstraction levels** | Enums, callables, protocols, dataclasses, and an indexed store all coexist with no layered hierarchy. | +| **Static and dynamic entities are indistinguishable** | At a glance, `Mission` and `Agent` look equally important. Their fundamentally different lifecycles and complexity levels are not reflected in the directory structure. | +| **Geometry types orphaned from their users** | `FrontArcAttack` and `SquareVision` are visually adjacent to `EntityStatus`, which has nothing to do with them. | +| **Hard to navigate** | Finding where `Beacon` is defined requires scrolling past hundreds of lines of unrelated geometry and protocol code. | + +--- + +## 3. Proposed Refactoring + +### 3.1 New directory layout + +``` +til_environment/ + entities/ + __init__.py ← re-exports every public name; all existing + import sites continue to work unchanged + base.py ← Entity base class, EntityStatus + protocols.py ← Attacker, Defender, Collector, Vision, Healer, + Product, Experience (all @runtime_checkable) + geometry.py ← AttackType, VisionType, _rotate(), + FrontArcAttack, AllAroundAttack, FRONT_ARC, + ALL_AROUND, SquareVision, SkewVision + dynamic.py ← Agent, Base, Beacon, Scout + (all import from protocols + geometry) + static.py ← Mission, Recon, PowerUp, PowerUpType, + AttackIntent + registry.py ← EntityRegistry +``` + +### 3.2 File-by-file responsibility + +#### `entities/base.py` +Defines the root of the entity hierarchy and its only required enum. + +- `EntityStatus` (IntEnum) +- `Entity` (dataclass) β€” `entity_id`, `team`, `position`, `status`, back-ref + wiring, `__setattr__` position-change hook, `alive`, `destroy()`, distance + helpers + +No imports from any other `entities/` submodule. All other submodules import +from this. + +#### `entities/protocols.py` +Pure structural typing β€” no game logic, no numpy arrays (except type hints). + +- `Attacker`, `Defender`, `Collector`, `Vision`, `Healer` +- `Product`, `Experience` + +Imports: `Protocol`, `runtime_checkable` from `typing`; `numpy` for type hints +only. No imports from `base.py` or any concrete entity file. + +#### `entities/geometry.py` +Pluggable geometry callables β€” no entity state, no registry. + +- `_rotate(offset, direction)` +- `AttackType` (Protocol) +- `FrontArcAttack`, `AllAroundAttack`, `FRONT_ARC`, `ALL_AROUND` +- `VisionType` (Protocol) with `.radius` property +- `SquareVision(n)`, `SkewVision(n, m)` + +Imports: `numpy`, `Protocol` from `typing`. No imports from any other +`entities/` submodule. + +#### `entities/static.py` +Team-neutral collectibles that carry no mutable game state. Spawned by +`ArenaGenerator`, consumed on agent contact, then destroyed. + +- `PowerUpType` (IntEnum) +- `AttackIntent` (dataclass) β€” logically lives here as a produced value +- `Mission(Entity)` β€” `reward_value`, `difficulty` +- `Recon(Entity)` β€” `reward_value` +- `PowerUp(Entity)` β€” `powerup_type`, `duration`, `strength` + +Imports: `base.py` only. These entities satisfy no trait protocols. + +#### `entities/dynamic.py` +Entities with rich mutable state that persist across multiple ticks and +explicitly implement trait protocols. + +- `Agent(Entity, Attacker, Defender, Vision, Experience)` +- `Base(Entity, Defender, Collector, Vision, Healer)` +- `Beacon(Entity, Defender, Collector, Vision, Healer)` +- `Scout(Entity, Vision)` + +Imports: `base.py`, `protocols.py`, `geometry.py`. + +#### `entities/registry.py` +The indexed store. Imports concrete entity types only to type the named +accessors. + +- `EntityRegistry` (full implementation) +- All four indexes: `pos_index`, `status_index`, `team_index`, `type_index` +- Primitive methods: `add`, `remove`, `get`, `at`, `clear` +- Protocol-keyed accessors: `defenders()`, `vision_providers()`, etc. + +Imports: `base.py`, `static.py`, `dynamic.py`, `protocols.py`. + +#### `entities/__init__.py` +Flat re-export of every public name, so all existing `from til_environment.entities import X` +calls continue to work with zero changes at import sites: + +```python +from til_environment.entities.base import Entity, EntityStatus +from til_environment.entities.protocols import ( + Attacker, Defender, Collector, Vision, Healer, Product, Experience, +) +from til_environment.entities.geometry import ( + AttackType, FrontArcAttack, AllAroundAttack, FRONT_ARC, ALL_AROUND, + VisionType, SquareVision, SkewVision, +) +from til_environment.entities.static import ( + PowerUpType, AttackIntent, Mission, Recon, PowerUp, +) +from til_environment.entities.dynamic import Agent, Base, Beacon, Scout +from til_environment.entities.registry import EntityRegistry + +__all__ = [ + "Entity", "EntityStatus", + "Attacker", "Defender", "Collector", "Vision", "Healer", + "Product", "Experience", + "AttackType", "FrontArcAttack", "AllAroundAttack", "FRONT_ARC", "ALL_AROUND", + "VisionType", "SquareVision", "SkewVision", + "PowerUpType", "AttackIntent", "Mission", "Recon", "PowerUp", + "Agent", "Base", "Beacon", "Scout", + "EntityRegistry", +] +``` + +No other file in the package needs to change its imports. + +### 3.3 Dependency graph + +``` +geometry.py protocols.py + \ \ + \ \ + ──→ dynamic.py ←── base.py ←── static.py + \ | + ──────────────────────→ registry.py + | + __init__.py (re-exports all) +``` + +No circular dependencies. `base.py` β†’ nothing. `protocols.py` β†’ nothing. +`geometry.py` β†’ nothing. `static.py` β†’ `base.py`. `dynamic.py` β†’ `base.py`, +`protocols.py`, `geometry.py`. `registry.py` β†’ all of the above. + +--- + +## 4. What Does Not Change + +| Thing | Why unchanged | +|-------|--------------| +| `EntityRegistry` semantics | Same four indexes, same protocol-keyed `type_index` behaviour | +| `type_index` keys protocols | `Defender`, `Vision`, etc. remain valid keys β€” MRO indexing is unaffected by the file split | +| All import sites outside `entities/` | `__init__.py` re-exports guarantee this | +| `dynamics.py` | No changes needed β€” still imports `Agent`, `Beacon`, etc. from `til_environment.entities` | +| `renderer.py`, `observation.py` | Same | +| v1 files (`gridworld.py`, `types.py`, etc.) | Untouched by policy | + +--- + +## 5. Migration Steps (Completed) + +1. βœ… Created `til_environment/entities/` directory +2. βœ… Wrote `base.py` β€” `EntityStatus` + `Entity` +3. βœ… Wrote `protocols.py` β€” all `@runtime_checkable` protocol classes +4. βœ… Wrote `geometry.py` β€” `_rotate`, both attack types, both vision types, singletons +5. βœ… Wrote `static.py` β€” `PowerUpType`, `AttackIntent`, `Mission`, `Recon`, `PowerUp` +6. βœ… Wrote `dynamic.py` β€” `Agent`, `Base`, `Beacon`, `Scout` with updated imports +7. βœ… Wrote `registry.py` β€” `EntityRegistry` + `Query` builder with updated imports +8. βœ… Wrote `__init__.py` β€” flat re-exports as shown above +9. βœ… Deleted `til_environment/entities.py` + +**Additional change during migration:** `EntityRegistry` gained a composable +`Query` builder (`registry.query().type(X).team(0).all()`) in `registry.py`, +which was not part of the original plan but was added alongside the split. diff --git a/til-26-ae-repo/til-26-ae/til_environment/docs/RUBRICS.md b/til-26-ae-repo/til-26-ae/til_environment/docs/RUBRICS.md new file mode 100644 index 0000000000000000000000000000000000000000..1df89c91ef1fe31ea28597adeec974a1671bd5d6 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/docs/RUBRICS.md @@ -0,0 +1,330 @@ +# RL Environment Quality Rubric β€” TIL Bomberman v2 + +This document rates the environment against standard criteria for production-ready +multi-agent RL environments. Each category is scored out of 10 with specific +evidence from the codebase. + +--- + +## Summary Scorecard + +| Category | Score | Grade | +|---|---|---| +| 1. Observation Space Design | 6 / 10 | Bβˆ’ | +| 2. Action Space Design | 8 / 10 | B+ | +| 3. Reward Function | 6 / 10 | Bβˆ’ | +| 4. Episode Structure | 8 / 10 | B+ | +| 5. Multi-Agent Design | 7 / 10 | B | +| 6. Reproducibility & Testability | 6 / 10 | Bβˆ’ | +| 7. Code Quality & Extensibility | 9 / 10 | Aβˆ’ | +| 8. Performance | 6 / 10 | Bβˆ’ | +| **Overall** | **50 / 80** | **B** | + +--- + +## 1. Observation Space Design β€” 6 / 10 + +### What is done well + +- **18-channel float32 spatial tensor** for agent/base viewcones. Each channel + is a single semantically meaningful layer (visibility, wall edges, entity + presence per team). Competitors can visualise any channel directly; no + bit-unpacking is needed before model input. +- **`populate_channels()`** is shared between agent directional viewcones and + base/beacon radius views, so the spatial encoding is consistent. +- **Action mask** is embedded in the observation dict, allowing masking-aware + policies (PPO + invalid-action masking) without any custom wrapper. +- **Dual spatial views** (`agent_viewcone` + `base_viewcone`) give an agent + both local egocentric and wider base-centred context in one observation. + +### Areas for improvement + +- **`direction` is a raw `Discrete(4)` integer.** Neural networks treat this + as an ordinal/continuous value (0 < 1 < 2 < 3 β‰ˆ ordered). A one-hot or + sine/cosine encoding (`sin(ΞΈ)`, `cos(ΞΈ)`) would avoid this. + +- **`step` is a raw `Discrete(num_iters + 1)` integer.** A value of 499 is + meaningless to a network that saw values 0–499 uniformly. Normalising to + `step / num_iters ∈ [0, 1]` (a `Box(0, 1, shape=(1,))`) would be better. + +- **`location` is absolute coordinates.** Absolute positions break + translational symmetry: a policy trained on one map region may not generalise + to another, even on the same maze layout. Position relative to the team base + would be more useful. + +- **`health` and `base_health` use raw `Box(0, max_health)` ranges** that span + four orders of magnitude (`max_agent_health=1000`). Normalising to `[0, 1]` + (or at least logarithmically scaling) would make gradient signals more + consistent. + +- **`FlattenDictWrapper` destroys spatial structure.** After flattening, the + `(H, W, 18)` viewcone tensor becomes a 1D vector. Policies must either + re-apply the correct reshape internally or receive no structural prior at all. + Providing a pre-flattened _and_ structured variant, or a `gym.spaces.Dict` + pathway for CNN-based policies, would serve both use cases. + +--- + +## 2. Action Space Design β€” 8 / 10 + +### What is done well + +- **Decoupled agent and base actions per agent** via `{"agent": Discrete(7), + "base": Discrete(3)}`. Every agent simultaneously controls both a mobile unit + and issues one command to the shared base, reducing policy complexity versus + a centralised base controller. +- **Action masking** is built into the environment's `observe()` return. + Illegal actions are intercepted by `Bomberman._execute_round()`, converted to + `STAY` / `DO_NOTHING`, and penalised β€” preventing gradient explosion from + out-of-distribution actions without requiring the policy to learn legality. +- **`Action`** and **`BaseAction`** are clean enums with meaningful names: + `FORWARD`, `ATTACK`, `ITEM`, `CRAFT_SCOUT`, etc. + +### Areas for improvement + +- **AEC ordering creates intra-round information asymmetry.** In PettingZoo's + AEC model, agents observe the state and act one by one within a single round. + Later-acting agents see the results of earlier agents' movements; earlier + agents cannot anticipate later ones. In a competitive 4-agent scenario this + can systematically advantage or disadvantage teams based on agent index. + Consider randomising agent order at the start of each round (currently the + order is fixed by `AgentSelector`). + +- **No continuous or hierarchical action option.** Discrete-only is correct for + a grid world, but providing a thin adapter for algorithms that expect a flat + `Discrete(N)` combined action (rather than the dict) would improve library + compatibility. + +--- + +## 3. Reward Function β€” 6 / 10 + +### What is done well + +- **14 configurable reward terms** via `RewardsConfig` in `config.py`. + Practitioners can tune every signal without touching code. +- **Dense movement feedback**: `agent_collide_wall`, `agent_collide_agent`, + `step_penalty`, `stationary_penalty` provide immediate gradient for basic + navigation. +- **Differential step/idle penalties** (`step_penalty` vs. `stationary_penalty`) + encourage activity without mandating aimless movement. +- **Combat attribution**: `attack_damage * damage_dealt` plus `attack_kill` + bonus give the attacker proportional credit. The victim's team receives a + corresponding `destroyed_team_entity` penalty. +- **Terminal rewards** (`own_base_destroyed`, `destroy_enemy_base`) are + symmetric and large enough to make base preservation a clear objective. + +### Areas for improvement + +- **`destroy_enemy_agent` in `RewardsConfig` is defined but never applied.** + `_apply_combat_rewards` uses `attack_kill` for the attacker but does not + apply `destroy_enemy_agent`. This is either dead config or a missing reward + path β€” either way it should be resolved. + +- **Mission collection reward (`collect_mission`) fires on pickup, not on + deposit.** The ARCHITECTURE.md and entity docstrings describe missions as + a carry-and-deposit mechanic ("agent carries to base for deposit reward"), + but the current reward fires immediately on tile pickup. If missions are + genuinely carry-and-deposit, the reward should trigger on deposit; if they + are immediate, the documentation should be corrected. + +- **No exploration signal.** On a procedurally generated 16Γ—16 maze, the map + is initially completely unknown. Without a curiosity or visit-count bonus, + agents may learn to camp near the base rather than explore. A small reward + for first-visit of each tile (from the agent's perspective) or for reducing + team fog-of-war would help. + +- **Reward scale is not normalised.** Values range from βˆ’50 (`own_base_destroyed`) + to +50 (`destroy_enemy_base`) with step penalties at βˆ’0.01. Many modern RL + libraries clip or normalise returns; an unnormalised scale that spans four + orders of magnitude can destabilise value learning. + +- **`truncation` reward defaults to 0.** A draw (both teams survive to `num_iters`) + is identical to an in-progress step from the reward perspective. Explicitly + rewarding survival or adding a resource-differential tie-breaker would make + the truncation outcome learnable. + +--- + +## 4. Episode Structure β€” 8 / 10 + +### What is done well + +- **Procedural map generation with seed control** (`ArenaGenerator.generate_walls` + cached per seed, `generate_episode` fresh each reset). Same seed β†’ same walls, + different episodes β†’ different entity scatter. This is the correct balance for + curriculum learning (fix layout) vs. generalisation (vary scatter). +- **10-phase round execution** is cleanly phased and documented: + movement β†’ attack β†’ damage β†’ craft β†’ scout β†’ collect β†’ upkeep β†’ termination. + Phases are independently testable. +- **Termination vs. truncation** are correctly separated (`terminations` dict + vs. `truncations` dict), compliant with the PettingZoo AEC spec. +- **`num_iters` is configurable** β€” short episodes for debugging, long episodes + for hard tasks. +- **Wall caching** means consecutive same-seed resets are fast (no maze + re-generation). + +### Areas for improvement + +- **Debug `print` / `time` statements are live in production code.** + `gridworld_v2.py:_execute_round` contains multiple `print("--- STEP START ---")` + and per-phase timing prints. These pollute stdout during training and slow + down every step. They should be replaced with `logging.debug(...)` or removed. + +- **`novice` config flag is declared but its effect is not apparent.** + `EnvConfig.novice: bool = False` exists in the schema but is not referenced in + `dynamics.py` or `gridworld_v2.py`. Either wire it or remove it. + +--- + +## 5. Multi-Agent Design β€” 7 / 10 + +### What is done well + +- **Competitive two-team structure** with symmetric starting conditions + (`_spread_starting_positions` maximises inter-team separation). +- **Shared team infrastructure** (base, beacons, scouts) creates meaningful + cooperative sub-tasks within each team. +- **Protocol-based dispatch** (`Defender`, `Vision`, `Healer`) means game phases + operate on protocols, not concrete types. Adding a new entity that heals, for + instance, requires only implementing `Healer` β€” no changes to the upkeep loop. +- **`EntityRegistry.type_index`** keys on protocol classes (via MRO inclusion), + making `_alive_of_type(Defender)` correct without manually listing concrete types. + +### Areas for improvement + +- **Centralised base action creates partial observability mismatch.** Each + agent independently submits a `base` action, but only one action per round + can actually be executed. There is no clear rule stated in the code for which + agent's base action "wins" when multiple agents issue conflicting craft commands. + This should be documented or enforced (e.g. priority queue, voting). + +- **Credit assignment for team-level events is coarse.** When a base is + destroyed, all surviving agents on the losing team get `own_base_destroyed`. + Dead agents (already terminated) receive nothing. The winning team gets + `destroy_enemy_base` per surviving agent, regardless of individual contribution. + Shaped intermediate rewards for base defence (e.g. healing the base, blocking + attacker paths) would reduce this sparseness. + +- **`num_teams` beyond 2 is untested territory.** The config allows `num_teams` + to be arbitrary, but team-win logic and reward attribution assume binary + winner/loser semantics. Multi-team (> 2) play would need explicit changes. + +--- + +## 6. Reproducibility & Testability β€” 6 / 10 + +### What is done well + +- **Seed-deterministic episodes**: `reset(seed=N)` β†’ `Dynamics.reset(N)` β†’ + `np_random(N)` β†’ deterministic maze and entity scatter. +- **`test.py`** provides an interactive keyboard harness for manual episode + inspection. +- **Configuration serialisation** (`save_config`, `load_config`) enables exact + experiment reproduction from a YAML file. + +### Areas for improvement + +- **No automated test suite** (`pytest`, `unittest`). The only test mechanism + is `test.py` (manual / interactive). Critical paths β€” observation shape, + reward event coverage, registry index consistency β€” are untested + programmatically. A minimal pytest suite covering at least: + - `reset()` produces valid observation shapes + - `step()` does not raise on all-STAY actions + - `entity.destroy()` is correctly reflected in all registry indexes + - observation space bounds match actual observation values + would significantly raise confidence. + +- **`VisionSystem` has an open TODO** (`dynamics.py:80`: "this seems to be + poorly used, and even more poorly thought out") indicating a known design + uncertainty. LOS is a critical component of partial observability β€” any + correctness issues here propagate silently into training. + +- **No benchmark / baseline.** Without a published random-policy baseline or + reference reward curve, it is hard to tell whether any training run is making + progress or is stuck. + +--- + +## 7. Code Quality & Extensibility β€” 9 / 10 + +### What is done well + +- **Strict separation of concerns**: `Bomberman` owns API, `Dynamics` owns state, + `Renderer` owns display, `EntityRegistry` owns storage. No cross-layer leakage. +- **`entities/` package split** cleanly layers entity concerns: + `base β†’ protocols β†’ geometry β†’ dynamic/static β†’ registry β†’ __init__`. + No circular imports. +- **OmegaConf structured config** catches typos at load time (structured schema + validation), is serialisable to YAML, and flows top-down from a single root. +- **Protocol-based polymorphism** (`Attacker`, `Defender`, etc.) means new + entity types can be added with zero changes to game loop code. +- **`Query` builder** on `EntityRegistry` provides composable, lazy multi-criteria + lookups without bespoke accessor proliferation. +- **`ArenaGenerator` two-stage design** (cached wall gen + fresh scatter) is + a well-motivated performance trade-off, clearly documented. +- The codebase is consistently docstring'd with design rationale, not just + parameter names. + +### Areas for improvement + +- **Debug `print` statements in `gridworld_v2.py`.** `_execute_round` has 8+ + `print()`/`time.time()` calls. These are training-time noise and should be + `logging.debug(...)`. + +- **`dynamics.py` docstring** still references `entities.py` (singular file) + rather than the `entities/` package β€” minor staleness. + +--- + +## 8. Performance β€” 6 / 10 + +### What is done well + +- **`EntityRegistry.pos_index`** is a pre-allocated 2D list-of-sets. Positional + lookups are O(1) with no hashing overhead. +- **`type_index`** is keyed by every MRO class at add-time (O(K) write, O(1) + read for any protocol or concrete type). +- **Wall caching** avoids expensive maze re-generation on same-seed resets. +- **`VisionSystem`** computes team-wide LOS once per round and shares results + across all observation builds. + +### Areas for improvement + +- **Per-step timing prints confirm bottlenecks.** The `print("Time taken for + render phase: …")` output in `_execute_round` shows the render and observation + phases as notable costs. Both are currently computed for *all* agents even + if many are dead; skipping terminated agents' observations would be a quick win. + +- **`build_agent_viewcone` and `build_radius_view`** rebuild full numpy arrays + on every call. For large grids and many beacons/scouts, this is significant. + Pre-allocating reusable buffers (write-to rather than allocate-new) would + reduce GC pressure. + +- **`supercover_line` (LOS check)** is called O(agents Γ— visible_cells) per + round. At grid_size=16 with 4 agents and wide viewcones this is manageable, + but at grid_size=32+ with beacons contributing additional radius views, LOS + becomes the dominant cost. A pre-computed LOS table keyed on `(from_tile, + to_tile, wall_set_hash)` would trade memory for speed if scaling is needed. + +- **No profiling baseline or benchmark.** Without a steps/second number at + the default config, it is impossible to measure regression between changes. + +--- + +## Recommendations by Priority + +| Priority | Recommendation | Effort | +|---|---|---| +| **High** | Remove / replace debug `print`/`time` statements in `_execute_round` | Low | +| **High** | Add a minimal `pytest` suite covering observation shape and registry integrity | Medium | +| **High** | Clarify mission collect-on-pickup vs. deposit semantics and align reward + docs | Low | +| **High** | Wire or remove the unused `destroy_enemy_agent` reward term | Low | +| **Medium** | Normalise `direction` (one-hot) and `step` (float ratio) in observations | Low | +| **Medium** | Normalise `health` and `base_health` to [0, 1] in observation space | Low | +| **Medium** | Randomise agent turn order each round to eliminate AEC ordering bias | Low | +| **Medium** | Document (or enforce) base-action conflict resolution when multiple agents craft | Low | +| **Medium** | Resolve or clarify the `VisionSystem` TODO in `dynamics.py` | Medium | +| **Low** | Add exploration shaping (first-visit bonus or fog-of-war reduction reward) | Medium | +| **Low** | Add a steps/second benchmark to catch performance regressions | Low | +| **Low** | Wire the `novice` config flag or remove it | Low | diff --git a/til-26-ae-repo/til-26-ae/til_environment/docs/to_tell_participants_about.md b/til-26-ae-repo/til-26-ae/til_environment/docs/to_tell_participants_about.md new file mode 100644 index 0000000000000000000000000000000000000000..bfb126715e0d4314a9d9c0b0fa7210ef4023baca --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/docs/to_tell_participants_about.md @@ -0,0 +1,3 @@ +Tell participants that agent and team semantics are kept seperate for geenralization purposes since one team has multiple entities. + +Tell participants the difference between last and step semantics \ No newline at end of file diff --git a/til-26-ae-repo/til-26-ae/til_environment/docs/walledge_refactor.md b/til-26-ae-repo/til-26-ae/til_environment/docs/walledge_refactor.md new file mode 100644 index 0000000000000000000000000000000000000000..f830011645c818b836189ba0a5c05d4a31808abf --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/docs/walledge_refactor.md @@ -0,0 +1,15 @@ +# Walledge refactor +Walls now have a canonical `WallEdge` dataclass in `ArenaState.wall_edges` dict (keyed by `((ax,ay),(bx,by))` canonical tuple). `_state` bits are kept as a derived/cached layer for fast collision and observation reads; `wall_edges` is the source of truth for `destructible`. + +**Why:** Edge-based wall state was mirrored across two tile bit fields, making it easy for code to update one side without the other. First-class objects eliminate that fragility and make blast destruction logic clean (`we.destructible` direct check instead of bit masking). + +**How to apply:** When writing any new code that touches wall creation, destruction, or querying β€” use `add_wall`, `destroy_wall`, `set_destructible`, `is_destructible`. Never set `_state` bits directly. The `wall_edges` dict is the place to read wall metadata. + +Implementation landed in: +- `til_environment/arena.py` β€” `WallEdge` dataclass, `ArenaState.wall_edges`, updated `add_wall`/`destroy_wall`/`set_destructible`/`is_destructible`/`indestructible_walls` +- `til_environment/dynamics.py` β€” `_directional_blast` iterates `wall_edges.values()` +- `til_environment/tests/` β€” all helpers updated to use `set_destructible` (not direct `_state` bit ops) + +**Renderer update explicitly deferred** β€” user said "go Option B first for now then update renderer after everything is done." The renderer still reads `_state` bits (which stay in sync), so it works correctly but doesn't yet leverage `WallEdge` objects for richer visuals. + +**Pre-existing test failures (unrelated):** `test_bomb_timer_channel_in_observation` and `test_bomb_timer_updates_with_countdown` reference `ViewChannel.BOMB_TIMER` which was renamed in a prior session. These 2 failures exist regardless of the WallEdge work. diff --git a/til-26-ae-repo/til-26-ae/til_environment/dynamics.py b/til-26-ae-repo/til-26-ae/til_environment/dynamics.py new file mode 100644 index 0000000000000000000000000000000000000000..0ce3e74349626e2d4eda565b9a5ebeaf6ea45659 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/dynamics.py @@ -0,0 +1,898 @@ +""" +dynamics.py - Game logic and physics for the TIL Bomberman (Bomberman-scoped). + +Owns all mutable game-state transitions: movement, collision detection, +bomb placement/detonation, damage, tile collection, resource economy, +agent freeze/respawn, and visibility. +""" + +from __future__ import annotations + +import logging + +from collections import defaultdict +import numpy as np +from gymnasium.utils.seeding import np_random +from omegaconf import DictConfig + +from til_environment.arena import ArenaGenerator, ArenaResult, ArenaState, WallEdge, WallResult # noqa: F401 +from til_environment.config import default_config, viewcone_tuple +from til_environment.entities.base import EntityStatus +from til_environment.events import EmitRule, Rewards +from til_environment.entities import ( + Agent, + AttackIntent, + Base, + Bomb, + EntityRegistry, + Item, + Mission, + RadiusAttack, + Recon, + Resource, + SquareVision, +) +from til_environment.entities.protocols import ( + Attacker, + Defender, + Timed, + Vision, +) +from til_environment.helpers import ( + idx_to_view, + _los_to_tile, + is_world_coord_valid, + supercover_line, + view_to_world, +) +from til_environment.observation import ( + NUM_CHANNELS, + build_agent_viewcone, + build_radius_view, +) +from til_environment.actions import ActionMask, Action +from til_environment.types import Direction + + +logger = logging.getLogger(__name__) + + +# ═══════════════════════════════════════════════════════════════════════════ +# Vision system +# ═══════════════════════════════════════════════════════════════════════════ +class VisionSystem: + """Line-of-sight and viewcone computation.""" + + def __init__( + self, + grid_size: int, + viewcone: tuple[int, int, int, int] = (2, 2, 2, 4), + ) -> None: + self.grid_size = grid_size + self.viewcone = viewcone + self.viewcone_width = viewcone[0] + viewcone[1] + 1 + self.viewcone_length = viewcone[2] + viewcone[3] + 1 + + def is_visible( + self, + start: np.ndarray, + end: np.ndarray, + walls: set[tuple[tuple[int, int], tuple[int, int]]], + ) -> bool: + if (start == end).all(): + return True + path = supercover_line(start, end) + for i in range(len(path) - 1): + tile, next_tile = path[i], path[i + 1] + dx = tile[0] - next_tile[0] + dy = tile[1] - next_tile[1] + if dx != 0 and dy != 0: + horiz0 = tuple(sorted((tile, (next_tile[0], tile[1])))) + horiz1 = tuple(sorted(((next_tile[0], tile[1]), next_tile))) + vert0 = tuple(sorted((tile, (tile[0], next_tile[1])))) + vert1 = tuple(sorted(((tile[0], next_tile[1]), next_tile))) + if (horiz0 in walls or horiz1 in walls) and ( + vert0 in walls or vert1 in walls + ): + return False + else: + edge = tuple(sorted((tile, next_tile))) + if edge in walls: + return False + return True + + def build_viewcone( + self, + agent_loc: np.ndarray, + agent_dir: int, + state: np.ndarray, + walls: set, + registry: EntityRegistry, + observer_team: int | None = None, + ) -> np.ndarray: + return build_agent_viewcone( + agent_pos=agent_loc, + agent_dir=agent_dir, + viewcone=self.viewcone, + state=state, + walls=walls, + registry=registry, + observer_team=observer_team, + grid_size=self.grid_size, + ) + + def get_team_visible_area( + self, + team: int, + registry: EntityRegistry, + walls: set, + state: np.ndarray, + ) -> set[tuple[int, int]]: + visible: set[tuple[int, int]] = set() + + for provider in registry.query().type(Vision).team(team): + if isinstance(provider, Agent): + agent = provider + direction = Direction(agent.direction) + for idx in np.ndindex((self.viewcone_length, self.viewcone_width)): + view_coord = idx_to_view(np.array(idx), self.viewcone) + world_coord = view_to_world(agent.position, direction, view_coord) + if not is_world_coord_valid(world_coord, self.grid_size): + continue + if self.is_visible(agent.position, world_coord, walls): + visible.add((int(world_coord[0]), int(world_coord[1]))) + else: + for wx, wy in provider.get_visible_cells(): + if 0 <= wx < self.grid_size and 0 <= wy < self.grid_size: + if self.is_visible( + provider.position, np.array([wx, wy]), walls + ): + visible.add((wx, wy)) + return visible + + +# ═══════════════════════════════════════════════════════════════════════════ +# Dynamics +# ═══════════════════════════════════════════════════════════════════════════ +class Dynamics: + """Owns all mutable game-state transitions.""" + + def __init__(self, cfg: DictConfig | None = None) -> None: + if cfg is None: + cfg = default_config() + self.cfg = cfg + + self.grid_size: int = int(cfg.env.grid_size) + self.num_teams: int = int(cfg.env.num_teams) + + self.viewcone = viewcone_tuple(cfg.dynamics.vision) + + self.arena_gen = ArenaGenerator( + grid_size=self.grid_size, + wall_prob=float(cfg.dynamics.arena.wall_prob), + wall_destructible_ratio=float(cfg.dynamics.arena.wall_destructible_ratio), + mission_prob=float(cfg.dynamics.arena.mission_prob), + recon_prob=float(cfg.dynamics.arena.recon_prob), + resource_prob=float(cfg.dynamics.arena.resource_prob), + novice=bool(cfg.env.novice), + base_respawn_steps=int(cfg.env.tile_respawn_steps), + ) + self.vision = VisionSystem(grid_size=self.grid_size, viewcone=self.viewcone) + self.action_mask = ActionMask(self) + self.rewards = Rewards(cfg) + + self.registry = EntityRegistry(self.grid_size) + self.arena_state: ArenaState | None = None + self._bomb_counter: int = 0 + self._respawn_counter: int = 0 + self._respawn_queue: list[dict] = [] + + # Populated by detonation_phase() each round; read by the renderer to + # draw blast-cell overlays on the frame where a bomb explodes. + self.last_explosions: list[dict] = [] + + # Per-team economy β€” floating-point ratios against bomb_cost. + self.team_resources: dict[int, float] = {t: 0.0 for t in range(self.num_teams)} + self.team_bombs: dict[int, int] = {t: 0 for t in range(self.num_teams)} + + self._rng: np.random.Generator | None = None + self._rng_seed: int | None = None + + # ── reward hook installation ────────────────────────────────────────── + + def _install_reward_hooks(self, entity) -> None: + """Install Rewards ``EmitRule`` wrappers on an entity's protocol methods. + + For ``Defender.receive_damage``: + * ``attack_damage`` β€” to attacker, scaled by actual damage dealt. + * ``attack_kill`` β€” to attacker when the defender's HP drops to zero + (we key on ``health <= 0`` rather than ``not e.alive`` since Agents + freeze rather than destroy themselves). + * ``destroy_wall`` β€” awarded in the detonation phase per wall edge removed. + + For ``Item.collect`` (Mission, Recon, Resource) β€” awards + ``collect_`` to the collecting agent. + """ + if isinstance(entity, Agent): + self.rewards.wrap_multi( + entity, + "receive_damage", + [ + EmitRule( + event_type="attack_damage", + recipient_fn=lambda r, amt, intent=None: ( + intent.attribute_rewards if intent is not None else None + ), + scale_by_return=True, + ), + # attack_kill is NOT wired here β€” damage_phase awards it after + # collecting all contributors so the reward can be split evenly. + # Equal-and-opposite penalty to the agent who was hit. + EmitRule( + event_type="attack_damage", + recipient_id=entity.entity_id, + scale_by_return=True, + multiplier=-1.0, + ), + ], + ) + elif isinstance(entity, Base): + self.rewards.wrap_multi( + entity, + "receive_damage", + [ + EmitRule( + event_type="attack_damage", + recipient_fn=lambda r, amt, intent=None: ( + intent.attribute_rewards if intent is not None else None + ), + scale_by_return=True, + ), + # Equal-and-opposite penalty to the agent whose base was hit. + EmitRule( + event_type="attack_damage", + recipient_fn=lambda r, amt, intent=None, b=entity: ( + self.registry.agents(b.team)[0].entity_id + if self.registry.agents(b.team) else None + ), + scale_by_return=True, + multiplier=-1.0, + ), + # destroy_enemy_base is NOT wired here β€” same reason as attack_kill. + # own_base_destroyed fires to the owning agent when base dies. + EmitRule( + event_type="own_base_destroyed", + recipient_fn=lambda r, amt, intent=None, b=entity: ( + self.registry.agents(b.team)[0].entity_id + if self.registry.agents(b.team) else None + ), + condition=lambda r, amt, intent=None, e=entity: not e.alive, + ), + ], + ) + if isinstance(entity, Item): + event_key = f"collect_{type(entity).__name__.lower()}" + self.rewards.wrap( + entity, + "collect", + event_key, + recipient_fn=lambda result, team, agent_id: agent_id, + ) + + # ── reset ────────────────────────────────────────────────────────────── + + def init_rng(self, seed: int | None = None) -> None: + self._rng, self._rng_seed = np_random(seed) + + def reset(self, seed: int | None = None) -> list[str]: + """Generate a new episode and populate entities.""" + if self._rng is None or seed is not None: + self.init_rng(seed) + + if self.arena_gen.novice: + episode_rng, _ = np_random(88) + episode_seed = 88 + else: + episode_rng = self._rng + episode_seed = int(self._rng.integers(0, 2**31)) + + result = self.arena_gen.generate_episode( + episode_rng, + episode_seed, + num_teams=self.num_teams, + ) + self.arena_state = ArenaState( + grid_size=self.grid_size, + wall_grid=result.wall_grid, + walls=result.walls, + ) + self.respawn_map: np.ndarray = result.respawn_map + + self.registry.clear() + self._bomb_counter = 0 + self._respawn_queue = [] + + # Reset per-team economy to config defaults. + rcfg = self.cfg.resources + self.team_resources = { + t: float(rcfg.starting_resources) for t in range(self.num_teams) + } + self.team_bombs = { + t: int(rcfg.starting_bombs) for t in range(self.num_teams) + } + + self.rewards.reset() + + agent_ids: list[str] = [] + for team in range(self.num_teams): + bcfg = self.cfg.entities.base + base = Base( + entity_id=f"base_team{team}", + team=team, + position=result.base_locations[team].copy(), + health=float(bcfg.health), + max_health=float(bcfg.max_health), + vision_type=SquareVision(int(bcfg.vision_radius)), + ) + self.registry.add(base) + self._install_reward_hooks(base) + + acfg = self.cfg.entities.agent + agent_id = f"agent_{team}" + agent = Agent( + entity_id=agent_id, + team=team, + position=result.starting_locations[team].copy(), + direction=int(result.starting_directions[team]), + health=float(acfg.health), + max_health=float(acfg.max_health), + freeze_duration=int(acfg.freeze_turns), + ) + self.registry.add(agent) + self._install_reward_hooks(agent) + agent_ids.append(agent_id) + + # Scatter static entities. + mcfg = self.cfg.entities.mission + rcfg_e = self.cfg.entities.recon + rescfg = self.cfg.entities.resource + mission_idx = 0 + recon_idx = 0 + resource_idx = 0 + for spec in result.static_entities: + if spec.kind == "mission": + e = Mission( + entity_id=f"mission_{mission_idx}", + team=None, + position=spec.position.copy(), + reward_value=float(mcfg.reward_value), + difficulty=float(mcfg.difficulty), + ) + self.registry.add(e) + self._install_reward_hooks(e) + mission_idx += 1 + elif spec.kind == "recon": + e = Recon( + entity_id=f"recon_{recon_idx}", + team=None, + position=spec.position.copy(), + reward_value=float(rcfg_e.reward_value), + ) + self.registry.add(e) + self._install_reward_hooks(e) + recon_idx += 1 + elif spec.kind == "resource": + e = Resource( + entity_id=f"resource_{resource_idx}", + team=None, + position=spec.position.copy(), + amount=float(rescfg.amount), + ) + self.registry.add(e) + self._install_reward_hooks(e) + resource_idx += 1 + + return agent_ids + + # ── observation ──────────────────────────────────────────────────────── + + def observe(self, agent_id: str) -> dict: + """Build the observation dictionary for a single agent.""" + agent = self.registry.get(agent_id) + if not isinstance(agent, Agent): + raise ValueError(f"{agent_id} is not an Agent") + + viewcone = self.vision.build_viewcone( + agent.position, + agent.direction, + self.arena_state._state, + self.arena_state.walls, + self.registry, + observer_team=agent.team, + ) + + bases = self.registry.query().type(Base).team(agent.team).all() + if bases: + base = bases[0] + base_view = build_radius_view( + center=base.position, + radius=base.vision_type.radius, + state=self.arena_state._state, + walls=self.arena_state.walls, + registry=self.registry, + observer_team=agent.team, + grid_size=self.vision.grid_size, + ) + base_health = base.health + else: + base_view = np.zeros((1, 1, NUM_CHANNELS), dtype=np.float32) + base_health = 0.0 + + return { + "agent_viewcone": viewcone, + "base_viewcone": base_view, + "direction": agent.direction, + "location": agent.position.copy(), + "base_location": base.position.copy() if bases else np.zeros(2, dtype=np.uint8), + "health": np.array([agent.health], dtype=np.float32), + "frozen_ticks": agent.frozen_ticks, + "base_health": np.array([base_health], dtype=np.float32), + "team_resources": np.array( + [self.team_resources.get(agent.team, 0.0)], dtype=np.float32 + ), + "team_bombs": self.team_bombs.get(agent.team, 0), + "step": 0, # overridden by Bomberman + "action_mask": self.action_mask.build(agent_id), + } + + # ── movement & collision ────────────────────────────────────────────── + + def _blocks_movement(self, agent: Agent, direction: Direction) -> bool: + """Return True if *agent* cannot step in *direction*. + + Blocked by any edge wall (indestructible or destructible) on the + current tile in *direction*, or an out-of-bounds destination. + """ + return self.arena_state.enforce_wall_collision(agent.position, direction) + + # Legacy alias used by a few callers (e.g. older tests). Kept deliberately. + def _enforce_wall_collision(self, agent: Agent, direction: Direction) -> bool: + return self._blocks_movement(agent, direction) + + def _agent_at( + self, position: np.ndarray, exclude: str | None = None + ) -> Agent | None: + for entity in self.registry.query().at(int(position[0]), int(position[1])): + if not isinstance(entity, Agent): + continue + if entity.entity_id == exclude: + continue + return entity + return None + + def move_agent(self, agent_id: str, action: int) -> dict: + """execute a single agent's movement-class action (or no-op).""" + agent = self.registry.get(agent_id) + if not isinstance(agent, Agent) or not agent.alive or agent.is_frozen: + return {"moved": False} + + _action = Action(action) + info: dict = { + "moved": False, + "collided_wall": False, + "collided_agent": None, + } + + if _action in (Action.FORWARD, Action.BACKWARD): + dir_idx = ( + agent.direction + if _action is Action.FORWARD + else (agent.direction + 2) % 4 + ) + direction = Direction(dir_idx) + + if self._blocks_movement(agent, direction): + info["collided_wall"] = True + self.rewards.award(agent_id, "agent_collide_wall") + return info + + next_loc = np.clip( + agent.position + direction.movement, 0, self.grid_size - 1 + ) + + other = self._agent_at(next_loc, exclude=agent_id) + if other is not None: + info["collided_agent"] = other.entity_id + self.rewards.award(agent_id, "agent_collide_agent") + return info + + agent.position = next_loc + info["moved"] = True + + self._handle_tile_pickup(agent, info) + + elif _action in (Action.LEFT, Action.RIGHT): + agent.direction = ( + agent.direction + (3 if _action is Action.LEFT else 1) + ) % 4 + info["moved"] = True + + # STAY / PLACE_BOMB -> movement is a no-op here. + return info + + # ═══════════════════════════════════════════════════════════════════════ + # Phased tick + # ═══════════════════════════════════════════════════════════════════════ + + def place_bomb_phase(self, actions: dict[str, int]) -> dict[str, dict]: + """ + do the bomb + + for each agent whose action is ``PLACE_BOMB``, if their team has at + least one bomb available (``team_bombs[team] > 0``) and the agent is + alive and not frozen, spawn a ``Bomb`` entity at the agent's tile and + decrement the team's bomb count. + """ + results: dict[str, dict] = {} + for agent_id, raw_action in actions.items(): + if Action(raw_action) is not Action.PLACE_BOMB: + continue + agent = self.registry.get(agent_id) + if not isinstance(agent, Agent) or not agent.alive or agent.is_frozen: + results[agent_id] = {"placed": None, "reason": "agent_unavailable"} + continue + if self.team_bombs.get(agent.team, 0) <= 0: + results[agent_id] = {"placed": None, "reason": "no_bombs"} + continue + + self.team_bombs[agent.team] -= 1 + self._bomb_counter += 1 + bcfg = self.cfg.entities.bomb + bomb_id = f"bomb_{agent.team}_{self._bomb_counter}" + bomb = Bomb( + entity_id=bomb_id, + team=agent.team, + position=agent.position.copy(), + attack=float(bcfg.attack), + blast_radius=int(bcfg.blast_radius), + timer=int(bcfg.timer), + attribute_rewards=agent_id, + attack_type=RadiusAttack(int(bcfg.blast_radius)), + ) + self.registry.add(bomb) + results[agent_id] = {"placed": bomb_id, "reason": "ok"} + return results + + def _directional_blast( + self, + bomb: "Bomb", + ) -> tuple[list[np.ndarray], int]: + """Compute blast cells and wall destructions for an expired bomb. + + Pass 1 β€” tile reachability (blast damage cells): + For each tile within the Chebyshev blast radius, compute LOS from + the bomb using all walls (indestructible AND destructible) as + blockers. Reachable tiles are added to blast_cells; agents there + take damage. + + Pass 2 β€” wall destruction (wall-first query): + Iterate directly over every wall edge in the arena. For each edge + within blast radius, check if the blast can reach *either* adjacent + tile. If yes and the edge is destructible, mark it for removal. + Querying walls directly (rather than deriving them from reachable + tiles) means walls are correctly found regardless of which path the + LOS took to reach either neighbour. + + Both passes read the unmodified wall state. Destructions are applied + after all LOS checks so removing one wall cannot cascade-open new blast + paths in the same detonation. + + Returns (blast_cells, walls_destroyed). The bomb's own cell is always + included. + """ + origin = bomb.position + ox, oy = int(origin[0]), int(origin[1]) + gs = self.arena_state.grid_size + r = bomb.blast_radius + state = self.arena_state._state # snapshot β€” read before any destruction + + # ── Pass 1: blast cells ─────────────────────────────────────────────── + blast: list[np.ndarray] = [] + reachable: set[tuple[int, int]] = set() + for tx in range(max(0, ox - r), min(gs, ox + r + 1)): + for ty in range(max(0, oy - r), min(gs, oy + r + 1)): + if _los_to_tile(ox, oy, tx, ty, state): + blast.append(np.array([tx, ty])) + reachable.add((tx, ty)) + + # ── Pass 2: wall destruction ────────────────────────────────────────── + # Iterate WallEdge objects directly β€” one object per physical wall, + # with a single authoritative .destructible flag. + walls_to_destroy: set[tuple[int, int, int]] = set() + for we in self.arena_state.wall_edges.values(): + if not we.destructible: + continue + # Within blast radius if either adjacent tile is in range. + if (max(abs(we.ax - ox), abs(we.ay - oy)) > r + and max(abs(we.bx - ox), abs(we.by - oy)) > r): + continue + # Destroy if the blast reaches either adjacent tile. + if (we.ax, we.ay) in reachable or (we.bx, we.by) in reachable: + walls_to_destroy.add((we.ax, we.ay, we.direction.value)) + + walls_destroyed = 0 + for wx, wy, wd in walls_to_destroy: + if self.arena_state.destroy_wall(wx, wy, Direction(wd)): + walls_destroyed += 1 + + return blast, walls_destroyed + + def resolve_movement_actions(self, actions: dict[str, int]) -> dict[str, dict]: + """resolve all movement / turn / stay actions.""" + infos: dict[str, dict] = {} + for agent_id, action in actions.items(): + infos[agent_id] = self.move_agent(agent_id, action) + return infos + + def detonation_phase(self) -> list[AttackIntent]: + """ + expired bombs detonate and produce AttackIntents. + + the first wall edge on each ray stops the ray: + destructible edges are destroyed + indestructible edges block the blast without being destroyed, cuz yknow + """ + intents: list[AttackIntent] = [] + self.last_explosions = [] + defender_ids: set[str] = self.registry.query().type(Defender).ids() + + timed_attackers = self.registry.query().type(Timed).type(Attacker).all() + attackers = [e for e in timed_attackers if e.expired and e.alive] + + for attacker in attackers: + blast_cells, wall_count = self._directional_blast(attacker) + self.last_explosions.append({ + "team": attacker.team, + "origin": attacker.position.copy(), + "blast_radius": attacker.blast_radius, + "cells": blast_cells, + }) + + placing_agent: str = attacker.attribute_rewards + for _ in range(wall_count): + self.rewards.award(placing_agent, "destroy_wall") + + # kablow + damage = attacker.attack_power + attacker.destroy() + + # collect defender targets within the filtered blast area. + target_ids: set[str] = set() + for c in blast_cells: + cx, cy = int(c[0]), int(c[1]) + target_ids |= self.registry.pos_index[cx][cy] # L bro + + for eid in target_ids & defender_ids: + target = self.registry.get(eid) + if target is None: + continue + if target.team is not None and target.team == attacker.team: + continue + intents.append( + AttackIntent( + attacker_id=attacker.entity_id, + defender_id=eid, + damage=damage, + attribute_rewards=attacker.attribute_rewards, + ) + ) + + return intents + + def damage_phase(self, intents: list[AttackIntent]) -> dict[str, dict]: + """ + defenders receive queued damage; kill/destroy rewards are split evenly + among all unique bomb-placers that dealt >0 damage to a given defender. + + ^ thanks claude. you will do damage anyways but yeah thanks for the help + """ + # Group intents by defender so we can split kill/destroy credit. + by_defender: dict[str, list[AttackIntent]] = defaultdict(list) + for intent in intents: + by_defender[intent.defender_id].append(intent) + + results: dict[str, dict] = {} + for defender_id, group in by_defender.items(): + defender = self.registry.get(defender_id) + if defender is None or not defender.alive: + continue + + # Track which placers dealt actual damage (for split credit). + contributors: list[str] = [] + + for intent in group: + # Skip if the defender died mid-group (Agent entered frozen state). + if not defender.alive: + break + if isinstance(defender, Agent) and defender.is_frozen: + break + + actual_dmg = defender.receive_damage(intent.damage, intent) + if actual_dmg > 0 and intent.attribute_rewards not in contributors: + contributors.append(intent.attribute_rewards) + + results[intent.attacker_id] = { + "attacked": defender_id, + "attack_damage": actual_dmg, + "attribute_rewards": intent.attribute_rewards, + } + + if not contributors: + continue + + split = 1.0 / len(contributors) + + # Agent killed β†’ freeze + split attack_kill among contributors. + if isinstance(defender, Agent) and defender.health <= 0 and not defender.is_frozen: + defender.frozen_ticks = defender.freeze_duration + for placer_id in contributors: + self.rewards.award(placer_id, "attack_kill", multiplier=split) + + # Base destroyed β†’ split destroy_enemy_base among contributors. + elif isinstance(defender, Base) and not defender.alive: + for placer_id in contributors: + self.rewards.award(placer_id, "destroy_enemy_base", multiplier=split) + + return results + + def upkeep(self) -> dict: + """ + end-of-round bookkeeping. + + * Tick Timed entity timers (bombs). + * Base-generated resources credited to every team (fixed rate). + * Auto-convert resources β†’ bombs whenever the pool reaches ``bomb_cost``. + * Tick agent freeze cooldowns; on hitting zero, respawn at full HP in + place (no teleport). + """ + summary: dict = {} + + # Tick all Timed entities (placed bombs). + for timed in list(self.registry.query().type(Timed)): + if timed.alive: + timed.tick_timer() + + # Base-generated resources. + rcfg = self.cfg.resources + base_rate = float(rcfg.base_resource_rate) + bomb_cost = float(rcfg.bomb_cost) + for team in range(self.num_teams): + self.team_resources[team] += base_rate + # Auto-convert surplus into bombs. + while self.team_resources[team] >= bomb_cost: + self.team_resources[team] -= bomb_cost + self.team_bombs[team] = self.team_bombs.get(team, 0) + 1 + + # Tick agent freeze / respawn. + for agent in self.registry.query().type(Agent): + if agent.is_frozen: + agent.frozen_ticks -= 1 + if agent.frozen_ticks <= 0: + agent.frozen_ticks = 0 + agent.health = agent.max_health + + # Tick collectible respawn queue. + next_queue = [] + for entry in self._respawn_queue: + entry["steps_remaining"] -= 1 + if entry["steps_remaining"] <= 0: + self._spawn_collectible(entry) + else: + next_queue.append(entry) + self._respawn_queue = next_queue + + summary["team_resources"] = dict(self.team_resources) + summary["team_bombs"] = dict(self.team_bombs) + return summary + + # ── collectible respawn ──────────────────────────────────────────────── + + def _queue_respawn( + self, kind: str, position: np.ndarray, kwargs: dict, steps: int + ) -> None: + """Schedule a collectible to reappear at *position* after *steps* ticks.""" + self._respawn_queue.append( + {"kind": kind, "position": position, "kwargs": kwargs, "steps_remaining": steps} + ) + + def _spawn_collectible(self, entry: dict) -> None: + """Materialise a queued collectible back into the registry.""" + self._respawn_counter += 1 + uid = self._respawn_counter + kind = entry["kind"] + pos = entry["position"] + kwargs = entry["kwargs"] + + if kind == "mission": + e = Mission(entity_id=f"mission_r{uid}", team=None, position=pos.copy(), **kwargs) + elif kind == "recon": + e = Recon(entity_id=f"recon_r{uid}", team=None, position=pos.copy(), **kwargs) + elif kind == "resource": + e = Resource(entity_id=f"resource_r{uid}", team=None, position=pos.copy(), **kwargs) + else: + return + + self.registry.add(e) + self._install_reward_hooks(e) + + # ── tile pickup ──────────────────────────────────────────────────────── + + def _handle_tile_pickup(self, agent: Agent, info: dict) -> None: + """Check if the agent just stepped onto a collectible Item tile.""" + x, y = int(agent.position[0]), int(agent.position[1]) + tile_entities = ( + self.registry.query().type(Item).status(EntityStatus.ACTIVE).at(x, y).all() + ) + + for entity in tile_entities: + pos = entity.position.copy() + px, py = int(pos[0]), int(pos[1]) + steps = int(self.respawn_map[px, py]) + if isinstance(entity, Resource): + amount = entity.collect(agent.team, agent.entity_id) + self.team_resources[agent.team] = ( + self.team_resources.get(agent.team, 0.0) + float(amount or 0.0) + ) + self._queue_respawn("resource", pos, {"amount": entity.amount}, steps) + elif isinstance(entity, Mission): + entity.collect(agent.team, agent.entity_id) + self._queue_respawn( + "mission", + pos, + {"reward_value": entity.reward_value, "difficulty": entity.difficulty}, + steps, + ) + elif isinstance(entity, Recon): + entity.collect(agent.team, agent.entity_id) + self._queue_respawn( + "recon", pos, {"reward_value": entity.reward_value}, steps + ) + + # ── hook called by Agent.receive_damage via event wrap ───────────────── + + def start_freeze(self, agent: Agent) -> None: + """Enter the frozen state on an agent whose HP just hit 0. + + Used as a callback after the reward hook fires on ``receive_damage``. + The agent persists on the grid, with frozen_ticks set from config. + """ + if agent.frozen_ticks <= 0 and agent.health <= 0: + agent.frozen_ticks = int(self.cfg.entities.agent.freeze_turns) + + # ── win / loss conditions ────────────────────────────────────────────── + + def check_termination(self) -> dict[int, str]: + """Check if any team has lost. + + In the Bomberman-scoped game, agents cannot be permanently killed + (they freeze and respawn), so only base destruction triggers loss. + """ + losses: dict[int, str] = {} + for team in range(self.num_teams): + bases_alive = self.registry.bases(team) + if not bases_alive: + losses[team] = "base_destroyed" + return losses + + # ── state access ─────────────────────────────────────────────────────── + + @property + def state(self) -> np.ndarray: + return self.arena_state._state + + def _in_bounds_cells(self, cells): + return [ + cell + for cell in cells + if (0 <= cell[0] < self.grid_size and 0 <= cell[1] < self.grid_size) + ] diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__init__.py b/til-26-ae-repo/til-26-ae/til_environment/entities/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..f0f7a0b9a6d55c3be978b89c558ec8392bc654c4 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/__init__.py @@ -0,0 +1,58 @@ +"""entities/ β€” Entity package for TIL Bomberman (Bomberman-scoped).""" + +from til_environment.entities.base import Entity, EntityStatus +from til_environment.entities.protocols import ( + Attacker, + Defender, + ExternalSideEffect, + Item, + Timed, + Vision, +) +from til_environment.entities.geometry import ( + AttackType, + RadiusAttack, + SkewVision, + SquareVision, + VisionType, + _rotate, +) +from til_environment.entities.static import ( + AttackIntent, + Mission, + Recon, + Resource, +) +from til_environment.entities.dynamic import Agent, Base, Bomb +from til_environment.entities.registry import EntityRegistry + +__all__ = [ + # base + "Entity", + "EntityStatus", + # protocols + "Attacker", + "Defender", + "ExternalSideEffect", + "Item", + "Timed", + "Vision", + # geometry + "AttackType", + "RadiusAttack", + "SkewVision", + "SquareVision", + "VisionType", + "_rotate", + # static + "AttackIntent", + "Mission", + "Recon", + "Resource", + # dynamic + "Agent", + "Base", + "Bomb", + # registry + "EntityRegistry", +] diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/__init__.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ffa026bd7fffe5c1daca18647a5972a18da240de Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/__init__.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/base.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/base.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..61a9f2a0d8c348b7fa18d0202b004980e96dc7c8 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/base.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/dynamic.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/dynamic.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..666586da00719bb172e57a2cd5a3610517cb41c7 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/dynamic.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/geometry.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/geometry.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..9f19ea9ab1955da8321bbe47906a063215ef266e Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/geometry.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/protocols.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/protocols.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..bc17d540c2a9f28e0c299cd7b5307bb047cc6df7 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/protocols.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/registry.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/registry.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..70d9c099758d853fcc4838824f5dbbbfee2c5326 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/registry.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/static.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/static.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..6f1ac507765abd777c23629804cb1b80b0d8362a Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/entities/__pycache__/static.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/base.py b/til-26-ae-repo/til-26-ae/til_environment/entities/base.py new file mode 100644 index 0000000000000000000000000000000000000000..78f82699b545b4fa11b171fad115b99ade6f90b0 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/base.py @@ -0,0 +1,94 @@ +"""entities/base.py β€” Root entity class and lifecycle enum. + +No imports from any other entities/ submodule. All other submodules import +from here. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from enum import IntEnum, auto +from typing import TYPE_CHECKING + +import numpy as np + +if TYPE_CHECKING: + pass + + +# --------------------------------------------------------------------------- +# Entity status enum +# --------------------------------------------------------------------------- +class EntityStatus(IntEnum): + """Lifecycle states shared by all entities.""" + + ACTIVE = auto() + DESTROYED = auto() + + +# --------------------------------------------------------------------------- +# Base entity +# --------------------------------------------------------------------------- +@dataclass +class Entity: + """Abstract base for every object that occupies a grid cell. + + Attributes + ---------- + entity_id : str + Unique identifier, e.g. ``"agent_0"``, ``"base_team1"``. + team : int | None + Owning team index. ``None`` for neutral entities. + position : np.ndarray + (x, y) grid coordinate. + status : EntityStatus + Whether the entity is still active on the board. + """ + + entity_id: str + position: np.ndarray + status: EntityStatus = EntityStatus.ACTIVE + team: int | None = None + + def __post_init__(self): + # Back-reference to the owning registry, set by EntityRegistry.add(). + # Stored as a plain attribute (not a dataclass field) so it is + # excluded from __init__, __repr__, and __eq__. + object.__setattr__(self, "_registry", None) + + def __setattr__(self, name: str, value) -> None: + if name == "position": + # Notify the registry so pos_index stays consistent. + reg = ( + object.__getattribute__(self, "_registry") + if "_registry" in self.__dict__ + else None + ) + if reg is not None and hasattr(self, "position"): + old = self.position + old_pos = (int(old[0]), int(old[1])) + object.__setattr__(self, name, value) + reg._on_position_changed(self, old_pos) + return + object.__setattr__(self, name, value) + + # -- convenience -------------------------------------------------------- + + @property + def alive(self) -> bool: + return self.status == EntityStatus.ACTIVE + + def destroy(self) -> None: + """Mark the entity as destroyed and notify the registry.""" + self.status = EntityStatus.DESTROYED + reg = self.__dict__.get("_registry") + if reg is not None: + reg._on_destroyed(self) + + def distance_to(self, other: "Entity") -> float: + """Euclidean distance to another entity.""" + return float(np.linalg.norm(self.position - other.position)) + + def manhattan_to(self, other: "Entity") -> int: + """Manhattan distance to another entity.""" + return int(np.sum(np.abs(self.position - other.position))) diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/dynamic.py b/til-26-ae-repo/til-26-ae/til_environment/entities/dynamic.py new file mode 100644 index 0000000000000000000000000000000000000000..939a89c4c64eec0808599286f0285a1a108c131d --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/dynamic.py @@ -0,0 +1,179 @@ +"""entities/dynamic.py β€” Mobile and stationary entities with rich mutable state. + +These entities persist across multiple ticks, can be damaged, moved, or produce +effects. Each explicitly inherits the trait protocols it satisfies. + +Imports: base.py, protocols.py, geometry.py. +""" + +from __future__ import annotations + +from dataclasses import dataclass, field +from typing import TYPE_CHECKING, Callable + +from til_environment.entities.base import Entity +from til_environment.entities.protocols import ( + Attacker, + Defender, + ExternalSideEffect, + Timed, + Vision, +) +from til_environment.entities.geometry import ( + AttackType, + VisionType, + SquareVision, + RadiusAttack, +) + +if TYPE_CHECKING: + from til_environment.entities.static import AttackIntent + +import numpy as np + + +# --------------------------------------------------------------------------- +# Agent +# --------------------------------------------------------------------------- +@dataclass +class Agent(Entity, Defender, Vision): + """A mobile agent controlled by a team's policy. + + Agents move on the grid, collect tiles, and place bombs. Health can + drop to zero β€” at which point the agent enters a "frozen" state for + ``freeze_turns`` upkeeps, then respawns in place at full HP. The agent + is never removed from the grid (``destroy()`` is never called during + normal gameplay). + """ + + health: float = 60.0 + max_health: float = 60.0 + direction: int = 0 + frozen_ticks: int = 0 + freeze_duration: int = 10 + vision_type: VisionType = field(default_factory=lambda: SquareVision(0)) + + def __post_init__(self): + super().__post_init__() + + @property + def is_frozen(self) -> bool: + return self.frozen_ticks > 0 + + def get_visible_cells(self) -> list[tuple[int, int]]: + """Vision protocol β€” delegates to ``self.vision_type``. + + The directional viewcone is applied by ``VisionSystem``; the + default ``SquareVision(0)`` is a no-op sentinel. + """ + return self.vision_type(self.position, self.direction) + + def receive_damage( + self, amount: float, intent: "AttackIntent | None" = None + ) -> float: + """Apply damage. If HP drops to 0, enter the frozen state. + + Unlike v1, we do NOT call ``destroy()`` β€” the agent persists on the + grid so the real-world robot counterpart isn't pulled off the mat. + Reward hooks (attack_damage, attack_kill) fire via event wrappers + installed by ``Dynamics``. + """ + if self.is_frozen or not self.alive: + return 0.0 + effective = max(0.0, amount) + before = self.health + self.health = max(0.0, self.health - effective) + return before - self.health + + def heal(self, amount: float) -> float: + """Heal the agent, clamped to ``max_health``.""" + before = self.health + self.health = min(self.max_health, self.health + amount) + return self.health - before + + +# --------------------------------------------------------------------------- +# Base +# --------------------------------------------------------------------------- +@dataclass +class Base(Entity, Defender, Vision): + """Stationary team structure. The team loses if its base is destroyed.""" + + health: float = 100.0 + max_health: float = 100.0 + vision_type: VisionType = field(default_factory=lambda: SquareVision(3)) + + def get_visible_cells(self) -> list[tuple[int, int]]: + return self.vision_type(self.position, 0) + + def receive_damage( + self, amount: float, intent: "AttackIntent | None" = None + ) -> float: + effective = max(0.0, amount) + before = self.health + self.health = max(0.0, self.health - effective) + if self.health <= 0 and self.alive: + self.destroy() + return before - self.health + + +# --------------------------------------------------------------------------- +# Bomb +# --------------------------------------------------------------------------- +@dataclass +class Bomb(Entity, Attacker, Timed, ExternalSideEffect): + """Timed area-of-effect explosive placed by an agent. + + Placed directly onto the board via the ``PLACE_BOMB`` action (no + inventory, no manufacture cost β€” the team's ``team_bombs`` counter is + decremented by Dynamics). Each upkeep tick decrements its ``timer``. + Once expired, the detonation phase resolves the blast: every Defender + within ``RadiusAttack(blast_radius)`` (including ``DestructibleWall``s) + takes ``attack`` damage. Edge walls (non-destructible) are unaffected. + """ + + attack: float = 30.0 + blast_radius: int = 3 + timer: int = 3 + attribute_rewards: str = "" # set at placement to the placer's entity_id + attack_type: AttackType = field(default_factory=lambda: RadiusAttack(3)) + _external_fn: Callable | None = field(default=None, repr=False) + + def __post_init__(self): + super().__post_init__() + if ( + not isinstance(self.attack_type, RadiusAttack) + or self.attack_type.r != self.blast_radius + ): + self.attack_type = RadiusAttack(self.blast_radius) + # Placed bombs tick down once immediately in upkeep, so compensate. + self.timer += 1 + + def get_attack_cells(self) -> list[np.ndarray]: + return self.attack_type(self.position, 0) + + def tick_timer(self) -> int: + self.timer -= 1 + return self.timer + + @property + def expired(self) -> bool: + return self.timer <= 0 + + # -- ExternalSideEffect protocol ---------------------------------------- + + def register_external_fn(self, fn: Callable) -> None: + self._external_fn = fn + + def apply_external_sideeffects(self) -> None: + if self._external_fn is not None: + self._external_fn(self.get_attack_cells()) + + # -- Attacker protocol -------------------------------------------------- + + def attack_sideeffects(self): + """On detonation: fire external side effects, then destroy self.""" + if not self.alive: + return + self.apply_external_sideeffects() + self.destroy() diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/geometry.py b/til-26-ae-repo/til-26-ae/til_environment/entities/geometry.py new file mode 100644 index 0000000000000000000000000000000000000000..dd19a1fbc301d2d598fbc87c62f9a00a152d409f --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/geometry.py @@ -0,0 +1,106 @@ +"""entities/geometry.py β€” Pluggable geometry callables for attack and vision. + +No entity state, no registry. Imports only numpy and stdlib typing. +No imports from any other entities/ submodule. +""" + +from __future__ import annotations + +from typing import Protocol + +import numpy as np + + +# --------------------------------------------------------------------------- +# Shared rotation helper +# --------------------------------------------------------------------------- +def _rotate(offset: np.ndarray, direction: int) -> np.ndarray: + """Rotate a RIGHT-relative offset by *direction* Γ— 90Β° clockwise.""" + o = offset.copy() + for _ in range(direction): + o = np.array([-o[1], o[0]]) + return o + + +# --------------------------------------------------------------------------- +# Attack types – pluggable geometry for attack cell computation +# --------------------------------------------------------------------------- +class AttackType(Protocol): + """Callable protocol: given attacker position and facing direction, return + the list of world-coordinate cells that can be hit. + """ + + def __call__(self, position: np.ndarray, direction: int) -> list[np.ndarray]: ... + + +class RadiusAttack: + """Square-radius blast hitting every cell within Chebyshev radius ``r``.""" + + def __init__(self, r: int) -> None: + self.r = r + self._offsets = [ + np.array([dx, dy]) for dx in range(-r, r + 1) for dy in range(-r, r + 1) + ] + + def __call__(self, position: np.ndarray, direction: int) -> list[np.ndarray]: + return [position + off for off in self._offsets] + + +# --------------------------------------------------------------------------- +# Vision types – pluggable geometry for area-of-sight computation +# --------------------------------------------------------------------------- +class VisionType(Protocol): + """Callable: given a world position and facing direction, return the list + of ``(x, y)`` tile coordinates this entity can see. + """ + + def __call__( + self, position: np.ndarray, direction: int + ) -> list[tuple[int, int]]: ... + + @property + def radius(self) -> int: ... + + +class SquareVision: + """Omnidirectional square vision covering a ``(2n+1) x (2n+1)`` area.""" + + def __init__(self, n: int) -> None: + self.n = n + self._offsets = [(dx, dy) for dx in range(-n, n + 1) for dy in range(-n, n + 1)] + + @property + def radius(self) -> int: + return self.n + + def __call__(self, position: np.ndarray, direction: int) -> list[tuple[int, int]]: + px, py = int(position[0]), int(position[1]) + return [(px + dx, py + dy) for dx, dy in self._offsets] + + +class SkewVision: + """Direction-aware vision: a ``(2n+1) x (2n+1)`` square extended by ``m`` + extra tiles deep in the facing direction. + """ + + def __init__(self, n: int, m: int) -> None: + self.n = n + self.m = m + self._base_offsets = [ + (dx, dy) for dx in range(-n, n + 1) for dy in range(-n, n + 1) + ] + self._ext_offsets = [ + (dx, dy) for dx in range(n + 1, n + m + 1) for dy in range(-n, n + 1) + ] + + @property + def radius(self) -> int: + return self.n + + def __call__(self, position: np.ndarray, direction: int) -> list[tuple[int, int]]: + px, py = int(position[0]), int(position[1]) + cells: list[tuple[int, int]] = [] + for raw_dx, raw_dy in self._base_offsets + self._ext_offsets: + rot = _rotate(np.array([raw_dx, raw_dy]), direction) + cells.append((px + int(rot[0]), py + int(rot[1]))) + return cells diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/protocols.py b/til-26-ae-repo/til-26-ae/til_environment/entities/protocols.py new file mode 100644 index 0000000000000000000000000000000000000000..d37d2a48a3622c2f8a6b28641df0472545c31d4d --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/protocols.py @@ -0,0 +1,141 @@ +""" +entities/protocols.py β€” Structural trait protocols for phased dispatch. + +Pure structural typing β€” no game logic. No imports from any other +entities/ submodule; concrete entity files import from here. + +^ +thanks claude + +if you're wondering why all these protocols exist, and why in general this repo is so heavily +typed and OOP'd its because the scope of this env used to be significantly larger and the env specs +more uncertain. Hence protocol maxxed. There are like 5 others that are now gone :skull: +""" + +from __future__ import annotations + +from typing import TYPE_CHECKING, Callable, Protocol, runtime_checkable + +import numpy as np + +if TYPE_CHECKING: + from til_environment.entities.geometry import AttackType, VisionType + from til_environment.entities.static import AttackIntent + + +# --------------------------------------------------------------------------- +# Trait protocols – structural subtyping for phased dispatch +# --------------------------------------------------------------------------- +@runtime_checkable +class Attacker(Protocol): + """Entity that can produce attack intents during the damage phase.""" + + attack: float + attack_type: "AttackType" + attribute_rewards: str + + @property + def attack_power(self) -> float: + return self.attack + + def get_attack_cells(self) -> list[np.ndarray]: ... + + def attack_sideeffects(self): + """Apply any side effects of the attack (e.g. self-destruction).""" + ... + + def trigger_attack(self): + """Fire side effects and return the attack's raw damage value.""" + self.attack_sideeffects() + return self.attack_power + + +@runtime_checkable +class Defender(Protocol): + """Entity that can receive damage during the damage phase.""" + + health: float + max_health: float + + def receive_damage( + self, amount: float, intent: "AttackIntent | None" = None + ) -> float: + """Apply damage. Return actual damage dealt after mitigation. + + The ``intent`` carries the attacker id so event wrappers on this + method can attribute attacker-side rewards. + """ + ... + + +@runtime_checkable +class Vision(Protocol): + """Entity that contributes vision to its team's shared view.""" + + vision_type: "VisionType" + + def get_visible_cells(self) -> list[tuple[int, int]]: + """Return the world-coordinate tiles this entity can see this tick.""" + ... + + +@runtime_checkable +class Timed(Protocol): + """Entity whose lifecycle is governed by a tick-down timer. + + The owning ``Dynamics`` decrements ``timer`` by one each upkeep phase. + When the timer reaches zero, the entity is considered "expired". + """ + + timer: int + + def tick_timer(self) -> int: + """Decrement the timer by one and return the new value.""" + ... + + @property + def expired(self) -> bool: + """True if the timer has hit zero (or below).""" + ... + + +@runtime_checkable +class Item(Protocol): + """Collectible on-the-ground entity. + + Concrete subclasses (Mission, Recon, Resource) each implement their own + ``collect(team, agent_id)`` method with the type-specific logic (e.g. + Resource credits the team pool, Mission/Recon award a flat reward). + """ + + team: str | None = None + used_by_id: str | None = None + + def owned(self) -> bool: + return self.team is not None + + def collect(self, team): + if self.team is not None: + raise ValueError(f"{type(self)} already owned by team {self.team}") + self.team = team + + def used(self) -> bool: + return self.used_by_id is None + + def use(self, agent_id: str): + if self.used_by_id is not None: + raise ValueError(f"Item already used by agent {self.used_by_id}") + self.used_by_id = agent_id + + +@runtime_checkable +class ExternalSideEffect(Protocol): + """Entity that holds an external callable and fires it as a side effect.""" + + def register_external_fn(self, fn: Callable) -> None: + """Store a callable to be invoked as the external side effect.""" + ... + + def apply_external_sideeffects(self) -> None: + """Invoke the registered external callable with entity-specific args.""" + ... diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/registry.py b/til-26-ae-repo/til-26-ae/til_environment/entities/registry.py new file mode 100644 index 0000000000000000000000000000000000000000..c209ec75895afa3ebea4593b1ac474af9fec04ec --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/registry.py @@ -0,0 +1,306 @@ +""" +entities/registry.py β€” Indexed container for O(1) entity lookups. + +Imports: base.py, static.py, dynamic.py, protocols.py. +""" + +from collections.abc import Iterable +from typing import Callable, Iterator, TypeVar, Generic, Protocol + +from til_environment.entities.base import Entity, EntityStatus +from til_environment.entities.protocols import ( + Attacker, + Defender, + Vision, +) +from til_environment.entities.static import ( + Mission, + Recon, + Resource, +) +from til_environment.entities.dynamic import Agent, Base, Bomb + + +# Query builder for lazy, composable filtering +T = TypeVar("T", bound=Entity) + + +class Query(Generic[T]): + """ + Extremely overengineered query class for composable entity filtering. + Very cool as an idea, but completely unnecessary. + Actually no it do make the code read nicer so yippee + """ + def __init__(self, registry: "EntityRegistry", ids: Iterable[str] | None = None): + self._registry = registry + self._ids: set[str] | None = set(ids) if ids is not None else None + self._filters: list[Callable[[T], bool]] = [] + + def type(self, cls: type) -> "Query[T]": + ids = self._registry.type_index.get(cls, set()) + return Query(self._registry, ids if self._ids is None else self._ids & ids) + + def team(self, team: int | None) -> "Query[T]": + ids = self._registry.team_index.get(team, set()) + return Query(self._registry, ids if self._ids is None else self._ids & ids) + + def status(self, status: EntityStatus) -> "Query[T]": + ids = self._registry.status_index.get(status, set()) + return Query(self._registry, ids if self._ids is None else self._ids & ids) + + def at(self, x: int, y: int) -> "Query[T]": + ids = self._registry.pos_index[x][y] + return Query(self._registry, ids if self._ids is None else self._ids & ids) + + def filter(self, fn: Callable[[T], bool]) -> "Query[T]": + self._filters.append(fn) + return self + + def all(self) -> list[T]: + ids = ( + self._ids if self._ids is not None else set(self._registry._entities.keys()) + ) + entities = [ + self._registry._entities[eid] + for eid in ids + if eid in self._registry._entities + ] + for f in self._filters: + entities = list(filter(f, entities)) + return entities + + def first(self) -> T | None: + all_ = self.all() + return all_[0] if all_ else None + + def __iter__(self) -> Iterator[T]: + return iter(self.all()) + + def __len__(self) -> int: + return len(self.all()) + + def ids(self) -> set[str]: + return set(e.entity_id for e in self.all()) + + def __repr__(self): + return f"" + + +EntityRegistryQuery = Query + + +class EntityRegistry: + """Indexed store of all entities on the board.""" + + EXCLUDED_TYPES = {object, Generic, Protocol} + + def __init__(self, grid_size: int = 0) -> None: + self.grid_size = grid_size + self._entities: dict[str, Entity] = {} + self.pos_index: list[list[set[str]]] = [ + [set() for _ in range(grid_size)] for _ in range(grid_size) + ] + self.status_index: dict[EntityStatus, set[str]] = { + EntityStatus.ACTIVE: set(), + EntityStatus.DESTROYED: set(), + } + self.team_index: dict[int | None, set[str]] = {} + self.type_index: dict[type, set[str]] = {} + + def query(self) -> Query[Entity]: + return Query(self) + + def _index_add(self, entity: Entity) -> None: + eid = entity.entity_id + self.pos_index[int(entity.position[0])][int(entity.position[1])].add(eid) + self.status_index[entity.status].add(eid) + self.team_index.setdefault(entity.team, set()).add(eid) + for cls in type(entity).__mro__: + if cls not in self.EXCLUDED_TYPES: + self.type_index.setdefault(cls, set()).add(eid) + + def _index_remove(self, entity: Entity) -> None: + eid = entity.entity_id + self.pos_index[int(entity.position[0])][int(entity.position[1])].discard(eid) + self.status_index.get(entity.status, set()).discard(eid) + self.team_index.get(entity.team, set()).discard(eid) + for cls in type(entity).__mro__: + if cls not in self.EXCLUDED_TYPES: + self.type_index.get(cls, set()).discard(eid) + + def _on_position_changed(self, entity: Entity, old_pos: tuple[int, int]) -> None: + eid = entity.entity_id + self.pos_index[old_pos[0]][old_pos[1]].discard(eid) + new_x, new_y = int(entity.position[0]), int(entity.position[1]) + self.pos_index[new_x][new_y].add(eid) + + def _on_destroyed(self, entity: Entity) -> None: + eid = entity.entity_id + self.status_index[EntityStatus.ACTIVE].discard(eid) + self.status_index[EntityStatus.DESTROYED].add(eid) + + # -- CRUD --------------------------------------------------------------- + + def add(self, entity: Entity) -> None: + if entity.entity_id in self._entities: + raise ValueError(f"Duplicate entity_id: {entity.entity_id}") + self._entities[entity.entity_id] = entity + entity._registry = self + self._index_add(entity) + + def remove(self, entity_id: str) -> Entity | None: + entity = self._entities.pop(entity_id, None) + if entity is not None: + self._index_remove(entity) + entity._registry = None + return entity + + def get(self, entity_id: str) -> Entity | None: + return self._entities.get(entity_id) + + def __contains__(self, entity_id: str) -> bool: + return entity_id in self._entities + + def __len__(self) -> int: + return len(self._entities) + + def __iter__(self): + return iter(self._entities.values()) + + # -- positional lookup (O(1)) ------------------------------------------ + + def at(self, x: int, y: int) -> list[Entity]: + """Return all alive entities at grid position (x, y).""" + return [ + e + for eid in self.pos_index[x][y] + if (e := self._entities.get(eid)) is not None and e.alive + ] + + # -- filtered views ----------------------------------------------------- + + def _alive_of_type_ids(self, cls: type) -> list[str]: + type_ids = self.type_index.get(cls, set()) + alive_ids = self.status_index[EntityStatus.ACTIVE] + return [eid for eid in (type_ids & alive_ids) if eid in self._entities] + + def _alive_of_type(self, cls: type) -> list[Entity]: + type_ids = self.type_index.get(cls, set()) + alive_ids = self.status_index[EntityStatus.ACTIVE] + return [ + self._entities[eid] + for eid in (type_ids & alive_ids) + if eid in self._entities + ] + + def _alive_of_type_team(self, cls: type, team: int | None) -> list[Entity]: + type_ids = self.type_index.get(cls, set()) + alive_ids = self.status_index[EntityStatus.ACTIVE] + team_ids = self.team_index.get(team, set()) + return [ + self._entities[eid] + for eid in (type_ids & alive_ids & team_ids) + if eid in self._entities + ] + + def _alive_of_types(self, *classes: type) -> list[Entity]: + alive_ids = self.status_index[EntityStatus.ACTIVE] + union: set[str] = set() + for cls in classes: + union |= self.type_index.get(cls, set()) + return [ + self._entities[eid] for eid in (union & alive_ids) if eid in self._entities + ] + + def _alive_of_types_team(self, team: int | None, *classes: type) -> list[Entity]: + alive_ids = self.status_index[EntityStatus.ACTIVE] + team_ids = self.team_index.get(team, set()) + union: set[str] = set() + for cls in classes: + union |= self.type_index.get(cls, set()) + return [ + self._entities[eid] + for eid in (union & alive_ids & team_ids) + if eid in self._entities + ] + + def by_type(self, cls: type) -> list[Entity]: + return [ + self._entities[eid] + for eid in self.type_index.get(cls, ()) + if eid in self._entities + ] + + def by_team(self, team: int) -> list[Entity]: + return [ + self._entities[eid] + for eid in self.team_index.get(team, ()) + if eid in self._entities + ] + + def by_type_and_team(self, cls: type, team: int) -> list[Entity]: + type_ids = self.type_index.get(cls, set()) + team_ids = self.team_index.get(team, set()) + return [ + self._entities[eid] + for eid in (type_ids & team_ids) + if eid in self._entities + ] + + # -- concrete-type accessors ------------------------------------------- + + def agents(self, team: int | None = None) -> list[Agent]: + if team is None: + return self._alive_of_type(Agent) # type: ignore[return-value] + return self._alive_of_type_team(Agent, team) # type: ignore[return-value] + + def bases(self, team: int | None = None) -> list[Base]: + if team is None: + return self._alive_of_type(Base) # type: ignore[return-value] + return self._alive_of_type_team(Base, team) # type: ignore[return-value] + + def bombs(self, team: int | None = None) -> list[Bomb]: + if team is None: + return self._alive_of_type(Bomb) # type: ignore[return-value] + return self._alive_of_type_team(Bomb, team) # type: ignore[return-value] + + def missions(self) -> list[Mission]: + return self._alive_of_type(Mission) # type: ignore[return-value] + + def recons(self) -> list[Recon]: + return self._alive_of_type(Recon) # type: ignore[return-value] + + def resources(self) -> list[Resource]: + return self._alive_of_type(Resource) # type: ignore[return-value] + + def alive(self) -> list[Entity]: + alive_ids = self.status_index[EntityStatus.ACTIVE] + return [self._entities[eid] for eid in alive_ids if eid in self._entities] + + # -- protocol-keyed trait accessors ------------------------------------ + + def attackers(self, team: int | None = None) -> list[Attacker]: + if team is None: + return self._alive_of_type(Attacker) # type: ignore[return-value] + return self._alive_of_type_team(Attacker, team) # type: ignore[return-value] + + def defenders(self, team: int | None = None) -> list[Defender]: + if team is None: + return self._alive_of_type(Defender) # type: ignore[return-value] + return self._alive_of_type_team(Defender, team) # type: ignore[return-value] + + def vision_providers(self, team: int | None = None) -> list[Vision]: + if team is None: + return self._alive_of_type(Vision) # type: ignore[return-value] + return self._alive_of_type_team(Vision, team) # type: ignore[return-value] + + def clear(self) -> None: + for entity in self._entities.values(): + entity._registry = None + self._entities.clear() + for col in self.pos_index: + for cell in col: + cell.clear() + self.status_index = {EntityStatus.ACTIVE: set(), EntityStatus.DESTROYED: set()} + self.team_index.clear() + self.type_index.clear() diff --git a/til-26-ae-repo/til-26-ae/til_environment/entities/static.py b/til-26-ae-repo/til-26-ae/til_environment/entities/static.py new file mode 100644 index 0000000000000000000000000000000000000000..0dd78f7e81570779709a905c48c607294dd50fc8 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/entities/static.py @@ -0,0 +1,105 @@ +"""entities/static.py β€” Stationary collectible / environmental entities. + +Entities defined here include: +- Mission / Recon β€” one-shot collectible reward tiles. +- Resource β€” collectible that credits the team resource pool. +- DestructibleWall β€” cell-filling Defender entity that blocks movement and + can be destroyed by a bomb blast. +- AttackIntent β€” data class for queued attacks (not an Entity). + +Imports: base.py, protocols.py. +""" + +from __future__ import annotations + +from dataclasses import dataclass + +from til_environment.entities.base import Entity +from til_environment.entities.protocols import Item + + +# --------------------------------------------------------------------------- +# Attack intent – a queued attack produced by an Attacker +# --------------------------------------------------------------------------- +@dataclass +class AttackIntent: + """A single attack that will be applied in the damage phase.""" + + attribute_rewards: str + attacker_id: str + defender_id: str + damage: float + + +# --------------------------------------------------------------------------- +# Mission +# --------------------------------------------------------------------------- +@dataclass +class Mission(Entity, Item): + """Collectible objective on the grid. + + Awards ``reward_value`` to the agent that collects it (via reward hook on + ``collect``), then destroys itself. + """ + + reward_value: float = 5.0 + difficulty: float = 1.0 + + def __post_init__(self): + super().__post_init__() + if self.team is not None: + self.team = None + + def collect(self, team, agent_id): + super().collect(team) + self.use(agent_id) + self.destroy() + + +# --------------------------------------------------------------------------- +# Recon +# --------------------------------------------------------------------------- +@dataclass +class Recon(Entity, Item): + """Lightweight collectible recon token on the grid.""" + + reward_value: float = 1.0 + + def __post_init__(self): + super().__post_init__() + if self.team is not None: + self.team = None + + def collect(self, team, agent_id): + super().collect(team) + self.use(agent_id) + self.destroy() + + +# --------------------------------------------------------------------------- +# Resource +# --------------------------------------------------------------------------- +@dataclass +class Resource(Entity, Item): + """ + Collectible resource tile. + + When collected, credits ``amount`` to the collecting agent's team + resource pool (handled by ``Dynamics``). The value is expressed as a + ratio against ``resources.bomb_cost``. + """ + + amount: float = 0.5 + + def __post_init__(self): + super().__post_init__() + if self.team is not None: + self.team = None + + def collect(self, team, agent_id): + super().collect(team) + self.use(agent_id) + self.destroy() + return self.amount + + diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/__init__.py b/til-26-ae-repo/til-26-ae/til_environment/events/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..aed8a9f7880ad9fd0d4203102d8535fd21238ac0 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/events/__init__.py @@ -0,0 +1,6 @@ +"""Events subsystem β€” logging + side-effect accumulation for RL.""" + +from til_environment.events.base import EmitRule, Event +from til_environment.events.rewards import Rewards + +__all__ = ["EmitRule", "Event", "Rewards"] diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/__init__.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..8fd3a6e07b3b7df33cc2ab171c08eb33265c0bd7 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/__init__.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/base.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/base.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..23f2562acf4dd13a37395495a95ea36b7b4757bc Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/base.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/rewards.cpython-312.pyc b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/rewards.cpython-312.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4aa63f9ff54302e6a7693abef3d53d98a9529224 Binary files /dev/null and b/til-26-ae-repo/til-26-ae/til_environment/events/__pycache__/rewards.cpython-312.pyc differ diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/base.py b/til-26-ae-repo/til-26-ae/til_environment/events/base.py new file mode 100644 index 0000000000000000000000000000000000000000..139d380a6efa895f5e38c56b0880302d63b5e6fe --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/events/base.py @@ -0,0 +1,198 @@ +""" +events/base.py β€” Base Event class. + +Events encapsulate two cross-cutting concerns that RL simulations generate +far more of than ordinary games/simulations: + +1. **Logging** β€” structured records of what happened, written to a + configurable endpoint (text file by default; tensorboard/other sinks + can be plugged in later). +2. **Side effects on external state** β€” most notably reward accumulation, + but the same machinery can host other "observer" concerns (metrics, + replays, curriculum signals, ...). + +Subclasses override ``emit`` to add their own bookkeeping, and may expose +``wrap``-style helpers that decorate entity methods so the side effect +fires automatically whenever the underlying event-function is called. + +^ +thanks claude + +If you're a human reading this, this class is meant to provide you an easier time with modifying +the dynamics of this environment. Say if you want specific logging for specific events, create +an emit rule and subclass this and tie it to an endpoint. That way you can figure out what's going +on under the hood and mutate your algos better. Or something + +""" + +from __future__ import annotations + +import functools +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Callable + + +@dataclass +class EmitRule: + """One emission rule attached to a wrapped method. + + A single call to the wrapped method can fire zero or more of these, + so a method like ``receive_damage`` can produce defender-side *and* + attacker-side rewards, plus conditional kill rewards, from one hook. + + Attributes + ---------- + event_type : str + Event identifier passed to ``Event.emit`` (and used by ``Rewards`` + as a config key for the reward value). + recipient_id : str | None + Static recipient. Mutually exclusive with ``recipient_fn``. + recipient_fn : Callable | None + Dynamic recipient lookup. Called as + ``recipient_fn(result, *args, **kwargs)`` where ``result`` is the + wrapped method's return value. Return ``None`` to skip this rule. + scale_by_return : bool + If True, multiply the reward by the wrapped method's return value. + condition : Callable | None + Optional predicate ``(result, *args, **kwargs) -> bool``. If + provided and returns False, the rule is skipped for this call. + Useful for kill-only emissions that depend on post-call state. + """ + + event_type: str + recipient_id: str | None = None + recipient_fn: Callable[..., str | None] | None = None + scale_by_return: bool = False + condition: Callable[..., bool] | None = None + multiplier: float = 1.0 + + def __post_init__(self) -> None: + if self.recipient_id is None and self.recipient_fn is None: + raise ValueError("EmitRule needs either recipient_id or recipient_fn") + + +class Event: + """Base class for all event-producing subsystems. + + Parameters + ---------- + name : str + Short identifier used as a log prefix (e.g. ``"rewards"``). + log_path : str | Path | None + File path to append log lines to. If ``None``, defaults to + ``./logs/events/.log`` relative to the current working + directory. Every Event always has a concrete log endpoint β€” + text logs are cheap and clarity is worth more than a few KB. + """ + + DEFAULT_LOG_DIR = Path("logs/events") + + def __init__(self, name: str, log_path: str | Path | None = None) -> None: + self.name = name + self.log_path: Path = ( + Path(log_path) + if log_path is not None + else self.DEFAULT_LOG_DIR / f"{name}.log" + ) + self.log_path.parent.mkdir(parents=True, exist_ok=True) + + # ── logging endpoint ────────────────────────────────────────────── + def log(self, message: str) -> None: + """Append a single line to the log endpoint.""" + with self.log_path.open("a") as f: + f.write(f"[{self.name}] {message}\n") + + def emit(self, event_type: str, **payload: Any) -> None: + """Record a structured event. + + Subclasses override this to add bookkeeping (e.g. reward accumulation). + The base implementation just logs a line. + """ + self.log(f"{event_type} {payload}") + + # ── method wrapping ─────────────────────────────────────────────── + def wrap( + self, + obj: object, + method_name: str, + event_type: str, + *, + recipient_id: str | None = None, + recipient_fn: Callable[..., str | None] | None = None, + scale_by_return: bool = False, + condition: Callable[..., bool] | None = None, + ) -> None: + """Convenience single-rule wrapper. + + Equivalent to ``wrap_multi(obj, method_name, [EmitRule(...)])``. + See ``EmitRule`` for parameter semantics. + """ + self.wrap_multi( + obj, + method_name, + [ + EmitRule( + event_type=event_type, + recipient_id=recipient_id, + recipient_fn=recipient_fn, + scale_by_return=scale_by_return, + condition=condition, + ) + ], + ) + + def wrap_multi( + self, + obj: object, + method_name: str, + rules: list[EmitRule], + ) -> None: + """Monkey-patch ``obj.method_name`` with a list of emission rules. + + The wrapped call runs normally and its return value is preserved. + After the call, every rule in ``rules`` is evaluated in order: + + * If ``rule.condition`` is set and returns False β†’ skip. + * Recipient resolved from ``rule.recipient_id`` or + ``rule.recipient_fn(result, *args, **kwargs)``. + * Multiplier = float(result) if ``rule.scale_by_return`` else 1.0. + * ``self.emit(rule.event_type, recipient_id=..., multiplier=...)``. + + A single call can therefore produce multiple emissions β€” e.g. + ``receive_damage`` credits both the defender (self-penalty) and + the attacker (via the passed ``intent``), plus optional + kill-conditioned emissions. + """ + if not rules: + raise ValueError("wrap_multi requires at least one EmitRule") + + original = getattr(obj, method_name) + + @functools.wraps(original) + def wrapper(*args: Any, **kwargs: Any) -> Any: + result = original(*args, **kwargs) + for rule in rules: + if rule.condition is not None and not rule.condition( + result, *args, **kwargs + ): + continue + if rule.recipient_fn is not None: + recipient = rule.recipient_fn(result, *args, **kwargs) + else: + recipient = rule.recipient_id + if recipient is None: + continue + multiplier = ( + float(result) * rule.multiplier + if rule.scale_by_return and result is not None + else rule.multiplier + ) + self.emit( + rule.event_type, + recipient_id=recipient, + multiplier=multiplier, + ) + return result + + setattr(obj, method_name, wrapper) diff --git a/til-26-ae-repo/til-26-ae/til_environment/events/rewards.py b/til-26-ae-repo/til-26-ae/til_environment/events/rewards.py new file mode 100644 index 0000000000000000000000000000000000000000..3193d0f7ff3b374d9659d5cc42922a8289e35d2a --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/events/rewards.py @@ -0,0 +1,116 @@ +"""events/rewards.py β€” Reward accumulation as an Event subclass. + +``Rewards`` is a specialised ``Event`` that maintains two parallel +accumulators: + +* ``_step`` β€” rewards received during the current round, cleared by + ``clear_step()`` at the end of each ``gridworld`` step. +* ``_episode`` β€” rewards received since the last ``reset()``, kept for + episode-level logging / scoring. + +All writes go through ``award()``, which looks up the reward value from +the config (``cfg.rewards.``), applies an optional multiplier, +and updates both accumulators. ``award()`` is also what ``Event.wrap`` +ends up calling via the ``emit`` override below, so wrapped entity +methods automatically feed the same pipeline. +""" + +from __future__ import annotations + +from pathlib import Path +from typing import Any + +from omegaconf import DictConfig + +from til_environment.events.base import Event + + +class Rewards(Event): + """Reward bookkeeping for the Bomberman environment. + + Parameters + ---------- + cfg : DictConfig + Full environment config. ``cfg.rewards`` is stored for lookups. + log_path : str | Path | None + Optional path to append reward events to (human-readable log). + """ + + def __init__(self, cfg: DictConfig, log_path: str | Path | None = None) -> None: + super().__init__(name="rewards", log_path=log_path) + self.config = cfg.rewards + self._step: dict[str, float] = {} + self._episode: dict[str, float] = {} + + # ── lifecycle ───────────────────────────────────────────────────── + def reset(self, agent_ids: list[str] | None = None) -> None: + """Clear both accumulators at the start of an episode. + + If ``agent_ids`` is given, the step/episode dicts are pre-seeded + with zeros for those ids so callers can iterate without KeyErrors. + """ + self._step.clear() + self._episode.clear() + if agent_ids: + for a in agent_ids: + self._step[a] = 0.0 + self._episode[a] = 0.0 + + def clear_step(self, agent_ids: list[str] | None = None) -> None: + """Reset the per-step accumulator (leave the episode accumulator).""" + if agent_ids is None: + for k in self._step: + self._step[k] = 0.0 + else: + for a in agent_ids: + self._step[a] = 0.0 + + # ── config lookup ───────────────────────────────────────────────── + def get(self, event: str, default: float = 0.0) -> float: + """Return the configured reward value for ``event``.""" + if hasattr(self.config, event): + return float(getattr(self.config, event)) + return default + + # ── accumulators ────────────────────────────────────────────────── + def award( + self, + recipient_id: str, + event: str, + multiplier: float = 1.0, + ) -> float: + """Credit ``recipient_id`` with the reward configured for ``event``. + + Returns the signed amount actually awarded (useful for debugging + and for tests). Unknown events resolve to ``0.0``. + """ + value = self.get(event) * float(multiplier) + if value == 0.0: + return 0.0 + self._step[recipient_id] = self._step.get(recipient_id, 0.0) + value + self._episode[recipient_id] = self._episode.get(recipient_id, 0.0) + value + return value + + # ── Event.emit override ─────────────────────────────────────────── + def emit(self, event_type: str, **payload: Any) -> None: + """Route wrapped-method events through ``award``. + + ``Event.wrap`` calls ``emit(event_type, recipient_id=..., multiplier=...)`` + after each wrapped call; we forward those into the accumulator. + Unknown payload shapes fall back to the base log behaviour. + """ + recipient = payload.get("recipient_id") + if recipient is None: + super().emit(event_type, **payload) + return + multiplier = float(payload.get("multiplier", 1.0)) + self.award(recipient, event_type, multiplier=multiplier) + + # ── read-only views ─────────────────────────────────────────────── + def step_rewards(self) -> dict[str, float]: + """Return a copy of the per-step reward dict.""" + return dict(self._step) + + def episode_rewards(self) -> dict[str, float]: + """Return a copy of the per-episode reward dict.""" + return dict(self._episode) diff --git a/til-26-ae-repo/til-26-ae/til_environment/flatten_dict.py b/til-26-ae-repo/til-26-ae/til_environment/flatten_dict.py new file mode 100644 index 0000000000000000000000000000000000000000..e611e57e207617e85cbbdaa9c25fdab22e8ae2c2 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/flatten_dict.py @@ -0,0 +1,24 @@ +import functools + +from gymnasium.spaces.utils import flatten, flatten_space +from pettingzoo.utils.env import ActionType, AECEnv, AgentID, ObsType +from pettingzoo.utils.wrappers.base import BaseWrapper + + +class FlattenDictWrapper(BaseWrapper[AgentID, ObsType, ActionType]): + """This wrapper flattens the Dict observation space.""" + + def __init__( + self, + env: AECEnv[AgentID, ObsType, ActionType], + ): + super().__init__(env) + + def observe(self, agent: AgentID) -> ObsType | None: + obs = super().observe(agent) + return flatten(self.env.observation_space(agent), obs) + + @functools.lru_cache(maxsize=None) + def observation_space(self, agent): + space = super().observation_space(agent) + return flatten_space(space) diff --git a/til-26-ae-repo/til-26-ae/til_environment/helpers.py b/til-26-ae-repo/til-26-ae/til_environment/helpers.py new file mode 100644 index 0000000000000000000000000000000000000000..88dd00139cd51206682ff367845c92ad5650debb --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/helpers.py @@ -0,0 +1,176 @@ +import numpy as np + +from til_environment.types import Direction + + +# helpers +def manhattan(arr1: np.ndarray, arr2: np.ndarray): + """Gets the manhattan distance between two locations""" + return np.sum(np.abs(arr1 - arr2)) + + +# bitwise operation helpers +def get_bit(value: int, bit_index: int): + """Get the value at a particular bit of the provided int""" + return (value >> bit_index) & 1 + + +def rotate_right(arr: np.ndarray, shift: int, bit_width: int = 8): + """Bitwise shift with rotation""" + return ((arr >> shift) | (arr << (bit_width - shift))) & ((1 << bit_width) - 1) + + +def zero_bit(arr: np.ndarray, bit_index: int): + """Zeroes out the particular bit of all values in the given array""" + mask = np.uint8(1) << bit_index + return arr & ~mask + + +# viewcone / world / numpy idx conversions +def view_to_world( + agent_loc: np.ndarray, agent_dir: Direction, view_coord: np.ndarray +) -> np.ndarray: + """ + Maps viewcone coordinate to world coordinate + """ + match Direction(agent_dir): + case Direction.RIGHT: + return agent_loc + view_coord + case Direction.DOWN: + return agent_loc - np.array((view_coord[1], -view_coord[0])) + case Direction.LEFT: + return agent_loc - view_coord + case Direction.UP: + return agent_loc + np.array((view_coord[1], -view_coord[0])) + + +def world_to_view( + agent_loc: np.ndarray, agent_dir: Direction, world_coord: np.ndarray +) -> np.ndarray: + """ + Maps world coordinate to viewcone coordinate + """ + match Direction(agent_dir): + case Direction.RIGHT: + return world_coord - agent_loc + case Direction.DOWN: + return np.array( + ((world_coord[1] - agent_loc[1]), (agent_loc[0] - world_coord[0])) + ) + case Direction.LEFT: + return agent_loc - world_coord + case Direction.UP: + return np.array( + ((agent_loc[1] - world_coord[1]), (world_coord[0] - agent_loc[0])) + ) + + +def idx_to_view( + idx: tuple[int, int], viewcone: tuple[int, int, int, int] +) -> np.ndarray: + """Converts numpy array index to viewcone index""" + return np.array(idx) - np.array((viewcone[0], viewcone[2])) + + +def view_to_idx( + view_coord: np.ndarray, viewcone: tuple[int, int, int, int] +) -> tuple[int, int]: + """Converts viewcone index to numpy array index""" + # using .item() to return a native python int, mostly just for neater debug printing + return (view_coord[0].item() + viewcone[0], view_coord[1].item() + viewcone[2]) + + +def is_idx_valid(idx: np.ndarray, viewcone_length: int, viewcone_width: int): + """Checks if a numpy index value is within the viewcone""" + return (0 <= idx[0] < viewcone_length) and (0 <= idx[1] < viewcone_width) + + +def is_world_coord_valid(world_coord: np.ndarray, size: int): + """Checks if a world coordinate value is within the world""" + return (0 <= world_coord[0] < size) and (0 <= world_coord[1] < size) + + +def supercover_line(start: np.ndarray, end: np.ndarray) -> list[tuple[int, int]]: + """Returns a list of (x, y) tiles the line passes through.""" + x0, y0 = start[0], start[1] + x1, y1 = end[0], end[1] + tiles = [] + + # get x and y distance you need to pass through + dx = x1 - x0 + dy = y1 - y0 + + nx = abs(dx) + ny = abs(dy) + + sign_x = 1 if dx > 0 else -1 if dx < 0 else 0 + sign_y = 1 if dy > 0 else -1 if dy < 0 else 0 + + # starting tile + px, py = x0.item(), y0.item() + tiles.append((px, py)) + + # distance travelled so far on each axis, ix and iy + ix = iy = 0 + while ix < nx or iy < ny: + # check for diagonal tile case + # fixes asymmetric tile visibility around perfectly diagonal corners + if (1 + 2 * ix) * ny == (1 + 2 * iy) * nx: + px += sign_x + py += sign_y + ix += 1 + iy += 1 + elif (1 + 2 * ix) * ny < (1 + 2 * iy) * nx: + px += sign_x + ix += 1 + else: + py += sign_y + iy += 1 + tiles.append((px, py)) + + return tiles + + +# maze generation +def convert_tile_to_edge(arena: np.ndarray, grid: np.ndarray): + """ + converts a numpy grid maze setup as generated by mazelib to the edge-centric style the env expects, + and modifies the input `arena` parameter inplace + """ + _grid = grid.astype(dtype=np.uint8) + arena += _grid[1::2, 0:-2:2] * (1 << Direction.UP.value) # maze top edge β†’ bit 3 + arena += _grid[1::2, 2::2] * (1 << Direction.DOWN.value) # maze bottom edge β†’ bit 1 + arena += _grid[0:-2:2, 1::2] * (1 << Direction.LEFT.value) # maze left edge β†’ bit 2 + arena += _grid[2::2, 1::2] * (1 << Direction.RIGHT.value) # maze right edge β†’ bit 0 + + +def _los_to_tile( + ox: int, + oy: int, + tx: int, + ty: int, + state: np.ndarray, +) -> bool: + """ + gosh i love python for loops + Return True if (tx, ty) is reachable from (ox, oy) with no wall crossing. + """ + if tx == ox and ty == oy: + return True + path = supercover_line(np.array([ox, oy]), np.array([tx, ty])) + for i in range(len(path) - 1): + cx, cy = path[i] + nx, ny = path[i + 1] + dx, dy = nx - cx, ny - cy + if dx != 0 and dy != 0: + h_dir = 0 if dx > 0 else 2 + v_dir = 1 if dy > 0 else 3 + h_blocked = bool(state[cx, cy] & (1 << h_dir)) or bool(state[nx, cy] & (1 << v_dir)) + v_blocked = bool(state[cx, cy] & (1 << v_dir)) or bool(state[cx, ny] & (1 << h_dir)) + if h_blocked and v_blocked: + return False + else: + d_val = 0 if dx == 1 else 1 if dy == 1 else 2 if dx == -1 else 3 + if state[cx, cy] & (1 << d_val): + return False + return True \ No newline at end of file diff --git a/til-26-ae-repo/til-26-ae/til_environment/observation.py b/til-26-ae-repo/til-26-ae/til_environment/observation.py new file mode 100644 index 0000000000000000000000000000000000000000..8dc8109ee2d32ccf3b27b32d8849f0accc2b4b56 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/observation.py @@ -0,0 +1,636 @@ +""" +observation.py - Multi-channel observation builders for the Bomberman Bomberman. + +Each agent's viewcone is an **H Γ— W Γ— C** ``float32`` tensor where every +channel is a semantically meaningful, human-readable layer. The exact +channel layout is the canonical ``ViewChannel`` enum below; consumers +should index by enum (``view[..., ViewChannel.BOMB]``) rather than by +literal index, so additions are non-breaking. + +Channel layout (aligned with ``ViewChannel`` β€” see the enum for the +authoritative source): + + Ch Name Range Semantics + ── ────────────────── ─────── ────────────────────────────────────────── + 0 VISIBLE {0, 1} 1 if the cell is within line-of-sight + 1 WALL_RIGHT {0, 1} wall on right edge (destructible or structural) + 2 WALL_DOWN {0, 1} wall on bottom edge (destructible or structural) + 3 WALL_LEFT {0, 1} wall on left edge (destructible or structural) + 4 WALL_UP {0, 1} wall on top edge (destructible or structural) + 5 TILE_EMPTY {0, 1} no collectible on this visible cell + 6 TILE_RECON {0, 1} recon token present + 7 TILE_MISSION {0, 1} mission token present + 8 TILE_RESOURCE {0, 1} resource tile present (credits team pool on pickup) + 9 ALLY_AGENT {0, 1} agent belonging to the observer's team + 10 ENEMY_AGENT {0, 1} agent belonging to a different team + 11 ALLY_BASE {0, 1} base belonging to the observer's team + 12 ENEMY_BASE {0, 1} base belonging to a different team + 13 DESTR_WALL_RIGHT {0, 1} right edge exists AND is destructible + 14 DESTR_WALL_DOWN {0, 1} bottom edge exists AND is destructible + 15 DESTR_WALL_LEFT {0, 1} left edge exists AND is destructible + 16 DESTR_WALL_UP {0, 1} top edge exists AND is destructible + 17 ALLY_BOMB {0, 1} active allied bomb present on this cell + 18 ENEMY_BOMB {0, 1} active enemy bomb present on this cell + 19 ALLY_BOMB_TIMER [0, ∞) countdown ticks remaining on the allied bomb + 20 ENEMY_BOMB_TIMER [0, ∞) countdown ticks remaining on the enemy bomb + 21 ALLY_AGENT_HEALTH [0, 1] health ratio of ally agent on this cell (0 = frozen) + 22 ENEMY_AGENT_HEALTH [0, 1] health ratio of enemy agent on this cell (0 = frozen) + 23 ALLY_BASE_HEALTH [0, 1] health ratio of ally base on this cell + 24 ENEMY_BASE_HEALTH [0, 1] health ratio of enemy base on this cell + +Wall channels (1–4) reflect all wall edges (destructible and structural). +Channels 13–16 (DESTR_WALL_*) mirror the wall channels but are only 1 when +that specific edge is also flagged destructible β€” agents can use these to +identify which edges a bomb will break. +TILE_EMPTY (5) is 1 for any visible cell that does not hold a collectible; +cells outside LOS have all channels at 0. + +Public API +---------- +* ``ViewChannel`` – IntEnum of channel indices (source of truth for ordering). +* ``NUM_CHANNELS`` – total channel count (= len(ViewChannel)); used for Box shapes. +* ``build_agent_viewcone`` – directional HΓ—WΓ—C tensor for an agent. +* ``build_radius_view`` – square (2R+1)Β²Γ—C tensor for a radius-based entity. +* ``populate_channels`` – shared core; call directly in tests or custom viewers. +""" + +from __future__ import annotations + +import functools +from enum import IntEnum + +import numpy as np + +from til_environment.entities import EntityRegistry +from til_environment.helpers import ( + get_bit, + idx_to_view, + is_world_coord_valid, + supercover_line, + view_to_world, +) +from til_environment.types import Direction # Wall kept for _WALL_TO_CHANNEL compat + + +# ═══════════════════════════════════════════════════════════════════════════ +# Channel definitions +# ═══════════════════════════════════════════════════════════════════════════ +class ViewChannel(IntEnum): + """Index of each channel in the H Γ— W Γ— C observation tensor.""" + + VISIBLE = 0 + + # walls (one channel per cardinal direction) + WALL_RIGHT = 1 + WALL_DOWN = 2 + WALL_LEFT = 3 + WALL_UP = 4 + + # tile type (one-hot) + TILE_EMPTY = 5 + TILE_RECON = 6 + TILE_MISSION = 7 + TILE_RESOURCE = 8 + + # entities β€” ally / enemy for each type + ALLY_AGENT = 9 + ENEMY_AGENT = 10 + ALLY_BASE = 11 + ENEMY_BASE = 12 + + # breakable terrain β€” one channel per direction (mirrors WALL_* but only set when destructible) + DESTR_WALL_RIGHT = 13 + DESTR_WALL_DOWN = 14 + DESTR_WALL_LEFT = 15 + DESTR_WALL_UP = 16 + + # active bombs on the cell β€” split by team so belief can track each independently + ALLY_BOMB = 17 + ENEMY_BOMB = 18 + ALLY_BOMB_TIMER = 19 + ENEMY_BOMB_TIMER = 20 + + # normalized health ratios for agents and bases ([0, 1]) + ALLY_AGENT_HEALTH = 21 + ENEMY_AGENT_HEALTH = 22 + ALLY_BASE_HEALTH = 23 + ENEMY_BASE_HEALTH = 24 + + +NUM_CHANNELS = len(ViewChannel) + +# Wall presence bits 0–3 (Direction.value) β†’ WALL_* channel. +_WALL_BIT_TO_CHANNEL: dict[int, ViewChannel] = { + Direction.RIGHT.value: ViewChannel.WALL_RIGHT, + Direction.DOWN.value: ViewChannel.WALL_DOWN, + Direction.LEFT.value: ViewChannel.WALL_LEFT, + Direction.UP.value: ViewChannel.WALL_UP, +} + +# Destructible flags bits 4–7 (Direction.value + 4) β†’ DESTR_WALL_* channel. +_DESTR_BIT_TO_CHANNEL: dict[int, ViewChannel] = { + Direction.RIGHT.value: ViewChannel.DESTR_WALL_RIGHT, + Direction.DOWN.value: ViewChannel.DESTR_WALL_DOWN, + Direction.LEFT.value: ViewChannel.DESTR_WALL_LEFT, + Direction.UP.value: ViewChannel.DESTR_WALL_UP, +} + +# NOTE: _TILE_TO_CHANNEL is removed. Tile presence (mission / recon) is now +# determined exclusively from the EntityRegistry, not from the state grid bits. + + +# ═══════════════════════════════════════════════════════════════════════════ +# Vectorized LOS kernel +# ═══════════════════════════════════════════════════════════════════════════ + +def _encode_path_steps( + path: list[tuple[int, int]], +) -> list[tuple[int, list[tuple[int, int, int]]]]: + """Convert a supercover path into encoded wall checks. + + Each step is (step_type, checks): + step_type=1 non-diagonal β€” checks = [(rx, ry, bit)] + step_type=2 diagonal β€” checks = [(h0), (h1), (v0), (v1)] + + Coordinates are relative to the path origin (agent position). + ``bit`` ∈ {0=RIGHT, 1=DOWN} indexes the canonical direction stored in the + state array (we always use the cell with the smaller coordinate). + """ + steps = [] + for k in range(len(path) - 1): + px, py = path[k] + nx, ny = path[k + 1] + sdx = nx - px + sdy = ny - py + + if sdx != 0 and sdy != 0: + # Diagonal step: four edge checks, blocked when (H0∨H1)∧(V0∨V1). + # H0: horizontal edge (px,py)–(nx,py) + # H1: vertical edge (nx,py)–(nx,ny) + # V0: vertical edge (px,py)–(px,ny) + # V1: horizontal edge (px,ny)–(nx,ny) + h0 = (min(px, nx), py, 0) # RIGHT bit of left cell + h1 = (nx, min(py, ny), 1) # DOWN bit of upper cell + v0 = (px, min(py, ny), 1) # DOWN bit of upper cell + v1 = (min(px, nx), ny, 0) # RIGHT bit of left cell + steps.append((2, [h0, h1, v0, v1])) + else: + if sdx > 0: + checks = [(px, py, 0)] # RIGHT bit of left cell + elif sdx < 0: + checks = [(nx, py, 0)] # RIGHT bit of left cell + elif sdy > 0: + checks = [(px, py, 1)] # DOWN bit of upper cell + else: + checks = [(px, ny, 1)] # DOWN bit of upper cell + steps.append((1, checks)) + + return steps + + +@functools.lru_cache(maxsize=8) +def _precompute_los_table(viewcone: tuple[int, int, int, int]) -> list[dict]: + """Build vectorized LOS lookup tables for every Direction Γ— viewcone cell. + + Cached by viewcone shape; called once per unique config at startup. + + Returns a list of 4 dicts (one per Direction) containing numpy arrays: + ``world_rel`` (N, 2) int32 β€” target cell offset from agent, per cell + ``step_type`` (N, P) int8 β€” 0=unused, 1=non-diagonal, 2=diagonal + ``step_rx`` (N, P, 4) int32 β€” relative x for each of 4 sub-checks + ``step_ry`` (N, P, 4) int32 β€” relative y + ``step_bit`` (N, P, 4) uint8 β€” bit index (0=RIGHT, 1=DOWN) + ``self_idx`` int β€” flat index of the agent's own cell + where N = vc_l Γ— vc_w and P = max path length across all cells. + """ + vc_l = viewcone[2] + viewcone[3] + 1 # rows (behind + ahead + 1) + vc_w = viewcone[0] + viewcone[1] + 1 # cols (left + right + 1) + N = vc_l * vc_w + + origin = np.zeros(2, dtype=np.int64) + tables = [] + + for d in range(4): + direction = Direction(d) + + world_rel = np.zeros((N, 2), dtype=np.int32) + all_steps: list[list] = [] + self_idx = 0 + + for n, (i, j) in enumerate(np.ndindex((vc_l, vc_w))): + view_coord = np.array( + [i - viewcone[2], j - viewcone[0]], dtype=np.int64 + ) + world_coord = view_to_world(origin, direction, view_coord) + world_rel[n] = world_coord + + if (world_coord == 0).all(): + self_idx = n + all_steps.append([]) + continue + + path = supercover_line(origin, world_coord) + all_steps.append(_encode_path_steps(path)) + + max_path = max((len(s) for s in all_steps), default=0) + + step_type = np.zeros((N, max_path), dtype=np.int8) + step_rx = np.zeros((N, max_path, 4), dtype=np.int32) + step_ry = np.zeros((N, max_path, 4), dtype=np.int32) + step_bit = np.zeros((N, max_path, 4), dtype=np.uint8) + + for n, steps in enumerate(all_steps): + for k, (stype, checks) in enumerate(steps): + step_type[n, k] = stype + for q, (rx, ry, bit) in enumerate(checks): + step_rx[n, k, q] = rx + step_ry[n, k, q] = ry + step_bit[n, k, q] = bit + + tables.append({ + "world_rel": world_rel, + "step_type": step_type, + "step_rx": step_rx, + "step_ry": step_ry, + "step_bit": step_bit, + "self_idx": self_idx, + "vc_l": vc_l, + "vc_w": vc_w, + }) + + return tables + + +def _vectorized_los( + ax: int, + ay: int, + state: np.ndarray, + table: dict, + grid_size: int, +) -> np.ndarray: + """Compute LOS visibility for all viewcone cells simultaneously. + + Returns a (N,) bool array where ``True`` means the cell is visible from + ``(ax, ay)``. Uses only numpy array ops β€” no Python loops over cells. + """ + world_rel = table["world_rel"] # (N, 2) + step_type = table["step_type"] # (N, P) + step_rx = table["step_rx"] # (N, P, 4) + step_ry = table["step_ry"] # (N, P, 4) + step_bit = table["step_bit"] # (N, P, 4) + + # Target world coords and OOB mask. + wx = ax + world_rel[:, 0] # (N,) + wy = ay + world_rel[:, 1] # (N,) + oob = (wx < 0) | (wx >= grid_size) | (wy < 0) | (wy >= grid_size) + + if step_type.shape[1] == 0: + visible = ~oob + visible[table["self_idx"]] = True + return visible + + # Absolute check coordinates β€” clip for safe indexing; OOB cells are + # already excluded by ``oob`` so clipped reads don't affect results. + cx = np.clip(ax + step_rx, 0, grid_size - 1) # (N, P, 4) + cy = np.clip(ay + step_ry, 0, grid_size - 1) # (N, P, 4) + + # Batch state lookup + bit extraction. + state_vals = state[cx, cy] # (N, P, 4) uint8 + hits = ((state_vals >> step_bit) & np.uint8(1)).astype(bool) # (N, P, 4) + + # Per-step blocking. + is_valid = step_type > 0 # (N, P) + is_nondiag = step_type == 1 # (N, P) + is_diag = step_type == 2 # (N, P) + + # Non-diagonal: blocked when hits[..., 0]. + nd_blocked = hits[..., 0] # (N, P) + # Diagonal: blocked when (H0∨H1) ∧ (V0∨V1). + dg_blocked = (hits[..., 0] | hits[..., 1]) & (hits[..., 2] | hits[..., 3]) + + step_blocked = (is_nondiag & nd_blocked) | (is_diag & dg_blocked) # (N, P) + + path_blocked = np.any(step_blocked & is_valid, axis=1) # (N,) + visible = ~oob & ~path_blocked + visible[table["self_idx"]] = True # own cell always visible + return visible + + +# ═══════════════════════════════════════════════════════════════════════════ +# Line-of-sight (kept for build_radius_view and VisionSystem.is_visible) +# ═══════════════════════════════════════════════════════════════════════════ +def _is_visible_los( + start: np.ndarray, + end: np.ndarray, + walls: set[tuple[tuple[int, int], tuple[int, int]]], +) -> bool: + """Return True if there is an unobstructed line of sight. + + All wall edges (destructible and indestructible alike) block LOS. + Both types are present in ``walls`` until a destructible edge is removed + by a bomb blast, at which point LOS opens naturally. + """ + if (start == end).all(): + return True + path = supercover_line(start, end) + for i in range(len(path) - 1): + tile, next_tile = path[i], path[i + 1] + dx = tile[0] - next_tile[0] + dy = tile[1] - next_tile[1] + if dx != 0 and dy != 0: + horiz0 = tuple(sorted((tile, (next_tile[0], tile[1])))) + horiz1 = tuple(sorted(((next_tile[0], tile[1]), next_tile))) + vert0 = tuple(sorted((tile, (tile[0], next_tile[1])))) + vert1 = tuple(sorted(((tile[0], next_tile[1]), next_tile))) + if (horiz0 in walls or horiz1 in walls) and ( + vert0 in walls or vert1 in walls + ): + return False + else: + edge = tuple(sorted((tile, next_tile))) + if edge in walls: + return False + return True + + +# ═══════════════════════════════════════════════════════════════════════════ +# Core channel-population routine +# ═══════════════════════════════════════════════════════════════════════════ +def populate_channels( + view: np.ndarray, + visible_world_coords: list[tuple[int, int]], + coord_to_idx: dict[tuple[int, int], tuple[int, int]], + state: np.ndarray, + registry: EntityRegistry, + observer_team: int | None, + grid_size: int, +) -> None: + """Fill an ``H Γ— W Γ— C`` tensor *in place* for every visible world cell. + + Parameters + ---------- + view : np.ndarray + Pre-allocated zeros, shape ``(H, W, NUM_CHANNELS)``, dtype float32. + visible_world_coords : list[tuple[int, int]] + World ``(x, y)`` coordinates that passed the LOS check. + coord_to_idx : dict + Maps world ``(x, y)`` β†’ view ``(row, col)`` index for stamping. + state : np.ndarray + Raw ``(grid_size, grid_size)`` uint8 arena. Wall presence bits occupy + positions 0–3 (aligned with ``Direction.value``); bits 4–7 encode + which of those edges are destructible (same direction order). + registry : EntityRegistry + Active entity registry. + observer_team : int | None + Team index of the observing entity (used for ally / enemy tagging). + grid_size : int + Side-length of the world grid. + """ + # ── 1. terrain (tile type + walls) for every visible cell ───────────── + for wx, wy in visible_world_coords: + idx = coord_to_idx.get((wx, wy)) + if idx is None: + continue + r, c = idx + + view[r, c, ViewChannel.VISIBLE] = 1.0 + + tile_val = int(state[wx, wy]) + + # bits 0–3: wall presence; bits 4–7: which of those edges are destructible + for direction in Direction: + if get_bit(tile_val, direction.value): + view[r, c, _WALL_BIT_TO_CHANNEL[direction.value]] = 1.0 + if get_bit(tile_val, direction.value + 4): + view[r, c, _DESTR_BIT_TO_CHANNEL[direction.value]] = 1.0 + + # ── 2. entities ─────────────────────────────────────────────────────── + # Build a quick set for O(1) lookups + visible_set = set(visible_world_coords) + + def _stamp( + pos: np.ndarray, + ally_ch: ViewChannel, + enemy_ch: ViewChannel, + entity_team: int | None, + ) -> None: + key = (int(pos[0]), int(pos[1])) + if key not in visible_set: + return + idx = coord_to_idx.get(key) + if idx is None: + return + r, c = idx + if observer_team is not None and entity_team == observer_team: + view[r, c, ally_ch] = 1.0 + else: + view[r, c, enemy_ch] = 1.0 + + for agent in registry.agents(): + _stamp( + agent.position, ViewChannel.ALLY_AGENT, ViewChannel.ENEMY_AGENT, agent.team + ) + key = (int(agent.position[0]), int(agent.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + health_ratio = float(max(0.0, agent.health / agent.max_health)) + if observer_team is not None and agent.team == observer_team: + view[idx[0], idx[1], ViewChannel.ALLY_AGENT_HEALTH] = health_ratio + else: + view[idx[0], idx[1], ViewChannel.ENEMY_AGENT_HEALTH] = health_ratio + + for base in registry.bases(): + _stamp(base.position, ViewChannel.ALLY_BASE, ViewChannel.ENEMY_BASE, base.team) + key = (int(base.position[0]), int(base.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + health_ratio = float(max(0.0, base.health / base.max_health)) + if observer_team is not None and base.team == observer_team: + view[idx[0], idx[1], ViewChannel.ALLY_BASE_HEALTH] = health_ratio + else: + view[idx[0], idx[1], ViewChannel.ENEMY_BASE_HEALTH] = health_ratio + + for bomb in registry.bombs(): + key = (int(bomb.position[0]), int(bomb.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + if observer_team is not None and bomb.team == observer_team: + view[idx[0], idx[1], ViewChannel.ALLY_BOMB] = 1.0 + view[idx[0], idx[1], ViewChannel.ALLY_BOMB_TIMER] = float(bomb.timer) + else: + view[idx[0], idx[1], ViewChannel.ENEMY_BOMB] = 1.0 + view[idx[0], idx[1], ViewChannel.ENEMY_BOMB_TIMER] = float(bomb.timer) + + # ── 3. static collectibles ───────────────────────────────────────────── + occupied_by_collectible: set[tuple[int, int]] = set() + + for mission in registry.missions(): + key = (int(mission.position[0]), int(mission.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + view[idx[0], idx[1], ViewChannel.TILE_MISSION] = 1.0 + occupied_by_collectible.add(key) + + for recon in registry.recons(): + key = (int(recon.position[0]), int(recon.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + view[idx[0], idx[1], ViewChannel.TILE_RECON] = 1.0 + occupied_by_collectible.add(key) + + for res in registry.resources(): + key = (int(res.position[0]), int(res.position[1])) + if key in visible_set: + idx = coord_to_idx.get(key) + if idx is not None: + view[idx[0], idx[1], ViewChannel.TILE_RESOURCE] = 1.0 + occupied_by_collectible.add(key) + + # TILE_EMPTY: visible cells with no static collectible + for wx, wy in visible_world_coords: + key = (wx, wy) + if key not in occupied_by_collectible: + idx = coord_to_idx.get(key) + if idx is not None: + view[idx[0], idx[1], ViewChannel.TILE_EMPTY] = 1.0 + + +# ═══════════════════════════════════════════════════════════════════════════ +# Directional viewcone builder (for Agents) +# ═══════════════════════════════════════════════════════════════════════════ +def build_agent_viewcone( + agent_pos: np.ndarray, + agent_dir: int, + viewcone: tuple[int, int, int, int], + state: np.ndarray, + walls: set[tuple[tuple[int, int], tuple[int, int]]], + registry: EntityRegistry, + observer_team: int | None, + grid_size: int, +) -> np.ndarray: + """Build an ``H Γ— W Γ— C`` observation tensor for an agent's viewcone. + + Parameters + ---------- + agent_pos : np.ndarray + ``(x, y)`` world coordinate of the observing agent. + agent_dir : int + Facing direction index (see ``Direction``). + viewcone : tuple[int, int, int, int] + ``(left, right, behind, ahead)`` offsets defining the cone shape. + state, walls, registry, observer_team, grid_size + Forwarded to ``populate_channels``. + + Returns + ------- + np.ndarray + Shape ``(viewcone_length, viewcone_width, NUM_CHANNELS)``, float32. + """ + vc_width = viewcone[0] + viewcone[1] + 1 + vc_length = viewcone[2] + viewcone[3] + 1 + + view = np.zeros((vc_length, vc_width, NUM_CHANNELS), dtype=np.float32) + + tables = _precompute_los_table(viewcone) + table = tables[agent_dir] + ax, ay = int(agent_pos[0]), int(agent_pos[1]) + + visible_flat = _vectorized_los(ax, ay, state, table, grid_size) # (N,) bool + + world_rel = table["world_rel"] # (N, 2) + visible_coords: list[tuple[int, int]] = [] + coord_to_idx: dict[tuple[int, int], tuple[int, int]] = {} + + for n, (i, j) in enumerate(np.ndindex((vc_length, vc_width))): + if not visible_flat[n]: + continue + wx = ax + int(world_rel[n, 0]) + wy = ay + int(world_rel[n, 1]) + key = (wx, wy) + visible_coords.append(key) + coord_to_idx[key] = (i, j) + + populate_channels( + view, + visible_coords, + coord_to_idx, + state, + registry, + observer_team, + grid_size, + ) + return view + + +# ═══════════════════════════════════════════════════════════════════════════ +# Circular radius view builder (for Bases, Beacons, Scouts) +# ═══════════════════════════════════════════════════════════════════════════ +def build_radius_view( + center: np.ndarray, + radius: int, + state: np.ndarray, + walls: set[tuple[tuple[int, int], tuple[int, int]]], + registry: EntityRegistry, + observer_team: int | None, + grid_size: int, +) -> np.ndarray: + """Build a ``(2R+1) Γ— (2R+1) Γ— C`` observation tensor centred on a position. + + Used for any entity with a circular ``vision_radius`` β€” bases, beacons, + and scouts all use this. + + Parameters + ---------- + center : np.ndarray + ``(x, y)`` world coordinate of the observing entity. + radius : int + Vision radius in tiles (Chebyshev / square region, filtered by LOS). + state, walls, registry, observer_team, grid_size + Forwarded to ``populate_channels``. + + Returns + ------- + np.ndarray + Shape ``(2*radius+1, 2*radius+1, NUM_CHANNELS)``, float32. + """ + side = 2 * radius + 1 + view = np.zeros((side, side, NUM_CHANNELS), dtype=np.float32) + + cx, cy = int(center[0]), int(center[1]) + + # Reuse the vectorized kernel with a symmetric square viewcone facing RIGHT + # (direction 0). (R,R,R,R) produces offsets (-R..R, -R..R) at direction=0, + # which matches the dx/dy iteration above exactly. + sym_vc = (radius, radius, radius, radius) + table = _precompute_los_table(sym_vc)[0] # direction 0 = RIGHT + + visible_flat = _vectorized_los(cx, cy, state, table, grid_size) # (N,) bool + + world_rel = table["world_rel"] # (N, 2) + visible_coords: list[tuple[int, int]] = [] + coord_to_idx: dict[tuple[int, int], tuple[int, int]] = {} + + for n, (i, j) in enumerate(np.ndindex((side, side))): + if not visible_flat[n]: + continue + wx = cx + int(world_rel[n, 0]) + wy = cy + int(world_rel[n, 1]) + key = (wx, wy) + visible_coords.append(key) + coord_to_idx[key] = (i, j) + + populate_channels( + view, + visible_coords, + coord_to_idx, + state, + registry, + observer_team, + grid_size, + ) + return view diff --git a/til-26-ae-repo/til-26-ae/til_environment/renderer.py b/til-26-ae-repo/til-26-ae/til_environment/renderer.py new file mode 100644 index 0000000000000000000000000000000000000000..36a2e4f724d3cb33885e458a5e0ec5040c3c870d --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/renderer.py @@ -0,0 +1,991 @@ +""" +renderer.py - Rendering subsystem for the TIL Bomberman environment. + +Encapsulates all pygame drawing logic so that the main Bomberman class only +needs to call ``Renderer.render()`` without knowing about surfaces, fonts, +or pixel math. + +Design notes +------------ +* The Renderer is **stateless with respect to game logic** – it reads the + current world state, entity registry, and observations but never mutates + them. +* Pygame initialisation is lazy: the display / surface is only created the + first time ``render()`` is called. +* Both ``"human"`` and ``"rgb_array"`` render modes are supported. +""" + +from __future__ import annotations + +import colorsys +import json +import warnings +from datetime import datetime +from pathlib import Path + +import numpy as np +import pygame + +from til_environment.entities import ( + Agent, + Base, + Bomb, + EntityRegistry, + Mission, + Recon, + Resource, +) +from itertools import zip_longest +from til_environment.helpers import get_bit, idx_to_view, view_to_world +from til_environment.observation import ViewChannel +from til_environment.types import Direction, Tile, Wall + + +def _json_default(o): + """Fallback JSON serialiser for numpy scalars/arrays and pathlib.Path.""" + if isinstance(o, np.generic): + return o.item() + if isinstance(o, np.ndarray): + return o.tolist() + if isinstance(o, Path): + return str(o) + raise TypeError(f"Object of type {type(o).__name__} is not JSON serialisable") + +# --------------------------------------------------------------------------- +# Colour palette +# --------------------------------------------------------------------------- +# Centralised colour definitions so tweaking the look-and-feel is trivial. + +COLORS = { + "background": (255, 255, 255), + "gridline": (211, 211, 211), + "no_vision": (80, 80, 80), + "wall": (0, 0, 0), + "direction_indicator": (0, 255, 0), + "text_default": "black", + # entity colours + "agent_team0": (0, 120, 255), + "agent_team1": (255, 60, 60), + "agent_team2": (60, 200, 60), + "agent_team3": (255, 200, 0), + "base": (160, 82, 45), + "mission": (147, 112, 219), + "recon": (255, 165, 0), + "resource": (128, 128, 128), + "destructible_wall": (160, 130, 85), + "bomb": (30, 30, 30), + "bomb_blast": (255, 80, 0), + "frozen_overlay": (180, 180, 255), +} + +# Fixed palette for the first four teams; teams beyond this are generated +# dynamically using golden-ratio hue spacing so they stay visually distinct. +_TEAM_COLOR_PALETTE: list[tuple[int, int, int]] = [ + COLORS["agent_team0"], # 0 β€” blue + COLORS["agent_team1"], # 1 β€” red + COLORS["agent_team2"], # 2 β€” green + COLORS["agent_team3"], # 3 β€” yellow +] +_GOLDEN_RATIO = 0.618033988749895 + + +def _team_color(team: int | None) -> tuple[int, int, int]: + if team is None: + return (200, 200, 200) + if team < len(_TEAM_COLOR_PALETTE): + return _TEAM_COLOR_PALETTE[team] + # Extend palette infinitely: golden-ratio hue walk starting after the fixed entries + hue = ((team - len(_TEAM_COLOR_PALETTE)) * _GOLDEN_RATIO + 0.45) % 1.0 + r, g, b = colorsys.hsv_to_rgb(hue, 0.80, 0.85) + return (int(r * 255), int(g * 255), int(b * 255)) + + +def chunk_list(lst, size): + """ + Splits a list into sublists of given size using zip_longest. + Fills missing values in the last chunk with None. + """ + if not isinstance(lst, list): + raise TypeError("Input must be a list.") + if not isinstance(size, int) or size <= 0: + raise ValueError("Chunk size must be a positive integer.") + + args = [iter(lst)] * size + return list(zip_longest(*args)) # Returns tuples + + +# --------------------------------------------------------------------------- +# Renderer +# --------------------------------------------------------------------------- +class Renderer: + """Handles all pygame-based rendering for the Bomberman. + + Parameters + ---------- + grid_size : int + Number of cells along one side of the square grid. + window_size : int + Height (and width, when debug is off) of the pygame window in pixels. + render_mode : str | None + ``"human"``, ``"rgb_array"``, or ``None``. + debug : bool + If ``True`` an additional panel is drawn showing per-agent observations. + viewcone_shape : tuple[int, int] + (viewcone_length, viewcone_width) used for the debug observation view. + viewcone : tuple[int, int, int, int] + The raw viewcone offsets ``(left, right, behind, ahead)``. + """ + + def __init__( + self, + grid_size: int, + window_size: int = 768, + render_mode: str | None = None, + debug: bool = False, + viewcone_shape: tuple[int, int] = (7, 5), + viewcone: tuple[int, int, int, int] = (2, 2, 2, 4), + replay_dir: str | None = None, + render_fps: int = 10, + num_teams: int = 2, + ) -> None: + self.grid_size = grid_size + self.window_size = window_size + self.render_mode = render_mode + self.debug = debug + self.viewcone_shape = viewcone_shape + self.viewcone = viewcone + self.replay_dir = Path(replay_dir) if replay_dir else None + # backup create folder if not + if self.replay_dir is not None: + self.replay_dir.mkdir(parents=True, exist_ok=True) + self.render_fps = render_fps + self.num_teams = num_teams + + self.window_width = int(window_size * 2) if debug else window_size + + # lazily initialised + self._window: pygame.Surface | None = None + self._clock: pygame.time.Clock | None = None + self._font: pygame.font.Font | None = None + self._video_writer = None # imageio writer, opened on first frame of each episode + self._episode_video_path: Path | None = None # path for the current episode + self._episode_count = 0 # monotonic per-Renderer episode counter + # Path of the most recently finalised mp4 (set by _finalise_writer). + # Consumers (e.g. the eval callback) can read this after start_episode() + # to correlate the just-closed episode with external metadata. + self.last_finalised_path: Path | None = None + + # Cached background surface: gridlines + walls drawn once, reused until + # the arena state changes (i.e. a destructible wall is blown up). + self._bg_surface: pygame.Surface | None = None + self._bg_state_key: bytes | None = None + + # Pre-allocated SRCALPHA surface for explosion cell overlays, sized to + # one grid cell. Re-used every detonation frame to avoid per-cell alloc. + self._explosion_cell_surf: pygame.Surface | None = None + + # -- public API --------------------------------------------------------- + + def render( + self, + state: np.ndarray, + registry: EntityRegistry, + observations: dict[str, dict], + rewards: dict[str, float], + actions: dict[str, int], + num_moves: int, + agent_ids: list[str], + selected_agent_id: str | None = None, + explosions: list[dict] | None = None, + respawn_overlay: "np.ndarray | None" = None, + ) -> np.ndarray | None: + """Draw one frame. + + Returns ``None`` for human mode, or an RGB numpy array for + ``"rgb_array"`` mode. + """ + if self.render_mode is None: + return None + + self._ensure_display() + + pix = self.window_size / self.grid_size + + # 1+2. Blit cached background (gridlines + walls). + # Only rebuilt when the arena state changes (destructible wall blown up). + self._blit_background(state, pix) + + # 3. explosion overlays β€” drawn before entities so agents/bases appear + # on top of the blast flash + if explosions: + self._draw_explosion_overlays(explosions, pix) + + # 4. entities from the registry + self._draw_entities(registry, pix, selected_agent_id) + + # 5. debug panel (per-agent observation views) + if self.debug: + self._draw_debug_panel( + observations, rewards, actions, num_moves, agent_ids, registry + ) + + # 6. optional respawn-timer overlay (toggled from play.py via T key) + if respawn_overlay is not None: + self._draw_respawn_overlay(respawn_overlay, pix) + + # 7. present + return self._present() + + def start_episode( + self, + prev_suffix: str | None = None, + prev_episode_stats: dict | None = None, + ) -> None: + """Finalise the current episode's video and prepare a fresh file path. + + Called by Bomberman.reset() so each episode gets its own timestamped + MP4. The writer itself is opened lazily on the first rendered frame so + no empty files are created for episodes that are never rendered. + + Parameters + ---------- + prev_suffix : str | None + If provided, the just-closed episode's file is renamed to append + this suffix (e.g., a score string) before the ``.mp4`` extension. + prev_episode_stats : dict | None + If provided, a JSON sidecar with the same stem as the just-closed + episode's mp4 is written alongside it, containing these stats. + """ + self._finalise_writer(prev_suffix, prev_episode_stats) + if self.replay_dir is not None: + self._episode_count += 1 + timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f") + self._episode_video_path = ( + self.replay_dir / f"{timestamp}_episode_{self._episode_count}.mp4" + ) + else: + self._episode_video_path = None + + def close( + self, + final_suffix: str | None = None, + final_episode_stats: dict | None = None, + ) -> None: + """Tear down the pygame display and finalise any in-progress video. + + Parameters + ---------- + final_suffix : str | None + Optional suffix to append to the final episode's filename. + final_episode_stats : dict | None + If provided, a JSON sidecar is written alongside the final mp4. + """ + self._finalise_writer(final_suffix, final_episode_stats) + if self._window is not None: + pygame.display.quit() + pygame.quit() + self._window = None + + def finalise_current_replay(self, suffix: str | None) -> None: + """Close and rename the current episode's video without teardown. + + Unlike ``close()`` this leaves the pygame window/surface alive so the + env can keep rendering. Useful when an external caller (e.g. the eval + callback) wants to tag the just-closed episode's replay with a score. + """ + self._finalise_writer(suffix) + + def _finalise_writer( + self, + suffix: str | None, + episode_stats: dict | None = None, + ) -> None: + """Close the current video writer and optionally rename + sidecar it.""" + if self._video_writer is not None: + self._video_writer.close() + self._video_writer = None + if ( + suffix + and self._episode_video_path is not None + and self._episode_video_path.exists() + ): + stem = self._episode_video_path.stem + ext = self._episode_video_path.suffix + renamed = self._episode_video_path.with_name(f"{stem}_{suffix}{ext}") + self._episode_video_path.rename(renamed) + self._episode_video_path = renamed + + # Sidecar JSON: written only when we actually produced an mp4 and the + # caller handed us stats. Same stem as the mp4, ``.json`` extension. + if ( + episode_stats is not None + and self._episode_video_path is not None + and self._episode_video_path.exists() + ): + json_path = self._episode_video_path.with_suffix(".json") + payload = { + "mp4_filename": self._episode_video_path.name, + "episode_index": self._episode_count, + **episode_stats, + } + try: + with open(json_path, "w") as f: + json.dump(payload, f, indent=2, default=_json_default) + except OSError as e: + warnings.warn(f"failed to write replay sidecar JSON {json_path}: {e}") + + # Record the mp4 path as just-finalised so external correlators can pick + # it up, then clear the "current" pointer (next episode gets a new one). + self.last_finalised_path = self._episode_video_path + self._episode_video_path = None + + # -- lazy initialisation ------------------------------------------------ + + def _ensure_display(self) -> None: + if self._window is None: + pygame.init() + if self.render_mode == "human": + self._window = pygame.display.set_mode( + (self.window_width, self.window_size) + ) + pygame.display.set_caption("TIL-AI Bomberman") + else: + self._window = pygame.Surface((self.window_width, self.window_size)) + + if self._clock is None and self.render_mode == "human": + self._clock = pygame.time.Clock() + + if self._font is None: + try: + self._font = pygame.font.Font("freesansbold.ttf", 12) + except Exception: + warnings.warn("unable to import font") + + def _present(self) -> np.ndarray | None: + if self.render_mode == "human": + pygame.event.pump() + pygame.display.update() + # Do NOT call clock.tick here β€” that would sleep inside env.step(), + # blocking the caller. Pacing belongs in the outer game loop. + + needs_frame = self.render_mode == "rgb_array" or self.replay_dir is not None + frame = ( + np.transpose(np.array(pygame.surfarray.pixels3d(self._window)), axes=(1, 0, 2)) + if needs_frame + else None + ) + + if self._episode_video_path is not None and frame is not None: + if self._video_writer is None: + import imageio + self._episode_video_path.parent.mkdir(parents=True, exist_ok=True) + try: + self._episode_video_path.parent.touch(exist_ok=True) + except (OSError, PermissionError) as e: + raise RuntimeError( + f"Cannot write to replay directory {self._episode_video_path.parent}: {e}" + ) from e + self._video_writer = imageio.get_writer( + str(self._episode_video_path), fps=self.render_fps, codec="libx264", quality=7 + ) + self._video_writer.append_data(frame) + + return frame if self.render_mode == "rgb_array" else None + + # -- primitive drawing helpers ------------------------------------------ + + def _draw_text(self, text: str, text_col: str = "black", **kwargs) -> None: + if self._font is not None and self._window is not None: + img = self._font.render(text, True, text_col) + rect = img.get_rect(**kwargs) + self._window.blit(img, rect) + + def _draw_respawn_overlay(self, respawn_map: "np.ndarray", pix: float) -> None: + """Draw per-cell respawn timers as coloured tiles + white text. + + Colour ranges from green (fast centre) through yellow to red (slow edge), + with a semi-transparent fill so the underlying entities remain visible. + """ + if self._window is None or self._font is None: + return + + vmin = int(respawn_map.min()) + vmax = int(respawn_map.max()) + span = max(vmax - vmin, 1) + + # Vectorized color computation β€” one numpy pass over the whole grid. + t = (respawn_map.astype(np.float32) - vmin) / span # (gs, gs), 0=fast 1=slow + R = (220.0 * t).astype(np.uint8) + G = (220.0 * (1.0 - t)).astype(np.uint8) + B = np.full_like(R, 40) + + # Scale each cell to pixΓ—pix pixels and build a (W, H, 3) surface array. + pix_int = max(1, round(pix)) + R_big = np.repeat(np.repeat(R, pix_int, axis=0), pix_int, axis=1) + G_big = np.repeat(np.repeat(G, pix_int, axis=0), pix_int, axis=1) + B_big = np.repeat(np.repeat(B, pix_int, axis=0), pix_int, axis=1) + rgb = np.stack([R_big, G_big, B_big], axis=-1) # (W, H, 3) + + overlay = pygame.surfarray.make_surface(rgb) + overlay.set_alpha(140) + self._window.blit(overlay, (0, 0)) + + # Text labels still need a per-cell loop (font.render is serial). + half = pix / 2 + for x in range(self.grid_size): + for y in range(self.grid_size): + label = self._font.render(str(int(respawn_map[x, y])), True, (255, 255, 255)) + lw, lh = label.get_size() + self._window.blit( + label, + (int(x * pix + half - lw / 2), int(y * pix + half - lh / 2)), + ) + + def _draw_gridlines( + self, + max_x: int, + max_y: int, + square_size: float, + x_corner: float = 0, + y_corner: float = 0, + width: int = 3, + *, + surface: pygame.Surface | None = None, + ) -> None: + target = surface if surface is not None else self._window + assert target is not None + for x in range(max_x + 1): + pygame.draw.line( + target, + COLORS["gridline"], + (x_corner + square_size * x, y_corner), + (x_corner + square_size * x, y_corner + square_size * max_y), + width=width, + ) + for y in range(max_y + 1): + pygame.draw.line( + target, + COLORS["gridline"], + (x_corner, y_corner + square_size * y), + (x_corner + square_size * max_x, y_corner + square_size * y), + width=width, + ) + + # -- higher-level draw routines ----------------------------------------- + + def _blit_background(self, state: np.ndarray, pix: float) -> None: + """Blit the cached background (gridlines + walls) onto the window. + + The surface is rebuilt only when the arena state changes, which only + happens when a destructible wall is destroyed by a bomb. Every other + frame is a single blit β€” O(1) regardless of grid size. + """ + state_key = state.tobytes() + if self._bg_surface is None or state_key != self._bg_state_key: + surf = pygame.Surface((self.window_size, self.window_size)) + surf.fill(COLORS["background"]) + self._draw_gridlines(self.grid_size, self.grid_size, pix, surface=surf) + self._draw_tiles(state, pix, surface=surf) + self._bg_surface = surf + self._bg_state_key = state_key + self._window.blit(self._bg_surface, (0, 0)) + + def _get_explosion_cell_surf(self, side: int) -> pygame.Surface: + """Return the shared SRCALPHA cell surface, (re)creating it if the tile size changed.""" + if self._explosion_cell_surf is None or self._explosion_cell_surf.get_width() != side: + self._explosion_cell_surf = pygame.Surface((side, side), pygame.SRCALPHA) + return self._explosion_cell_surf + + def _draw_explosion_overlays(self, explosions: list[dict], pix: float) -> None: + """Draw blast-cell fills and radius outlines for bombs that detonated this frame. + + Each blast cell gets a semi-transparent fill in a lightened variant of + the owning team's colour, making it easy to see which team's bomb + exploded and which cells were affected. The blast-radius bounding box + is also drawn so the full potential area is visible. + """ + assert self._window is not None + for exp in explosions: + team_color = _team_color(exp["team"]) + # Lighten: blend 60% toward white for the fill tint. + light_color = tuple(min(255, int(c * 0.4 + 255 * 0.6)) for c in team_color) + + # Cell fills β€” semi-transparent overlay. + # Reuse one pre-allocated SRCALPHA surface to avoid per-cell alloc. + side = int(pix) + cell_surf = self._get_explosion_cell_surf(side) + cell_surf.fill((*light_color, 170)) + for cell in exp["cells"]: + x, y = int(cell[0]), int(cell[1]) + self._window.blit(cell_surf, (x * pix, y * pix)) + + # Blast-radius bounding box outline (same as the live-bomb outline, + # but drawn 2 px wide and in the team colour for the detonation frame). + ox, oy = int(exp["origin"][0]), int(exp["origin"][1]) + r = exp["blast_radius"] + r_pix = (r + 0.5) * pix + cx_px = (ox + 0.5) * pix + cy_px = (oy + 0.5) * pix + blast_rect = pygame.Rect(cx_px - r_pix, cy_px - r_pix, 2 * r_pix, 2 * r_pix) + pygame.draw.rect(self._window, team_color, blast_rect, width=2) + + def _draw_tiles( + self, + state: np.ndarray, + pix: float, + surface: pygame.Surface | None = None, + ) -> None: + """Draw wall lines from the raw state array. + + Static entities (missions, recon tokens) are drawn separately by + ``_draw_entities`` via the EntityRegistry. Wall presence is in bits + 0–3; bits 4–7 flag which of those edges are destructible (drawn in + a different colour). + """ + target = surface if surface is not None else self._window + assert target is not None + for x, y in np.ndindex((self.grid_size, self.grid_size)): + tile_val = state[x, y] + for wall in Wall: + # Wall enum values are 4-7 (v1); subtract 4 to get the + # presence bit (0-3) in the v2 _state encoding. + # The same index without the -4 shift gives the destructible + # flag bit (4-7). + presence_bit = wall.value - 4 + if get_bit(tile_val, presence_bit): + color = ( + COLORS["destructible_wall"] + if get_bit(tile_val, wall.value) + else 0 + ) + wall.draw(target, x, y, pix, color=color) + + def _draw_entities( + self, registry: EntityRegistry, pix: float, selected_agent_id: str | None = None + ) -> None: + """Draw all entities from the registry onto the main grid.""" + assert self._window is not None + + for base in registry.bases(): + self._draw_base(base, pix) + + for mission in registry.missions(): + self._draw_mission(mission, pix) + + for recon in registry.recons(): + self._draw_recon(recon, pix) + + for resource in registry.resources(): + self._draw_resource(resource, pix) + + for bomb in registry.bombs(): + self._draw_bomb(bomb, pix) + + for agent in registry.agents(): + self._draw_agent(agent, pix, selected=agent.entity_id == selected_agent_id) + + def _draw_agent(self, agent: Agent, pix: float, selected: bool = False) -> None: + assert self._window is not None + color = _team_color(agent.team) + cx = (agent.position[0] + 0.5) * pix + cy = (agent.position[1] + 0.5) * pix + + if selected: + pygame.draw.circle( + self._window, (255, 255, 0), (cx, cy), pix / 3 + 4, width=3 + ) + + # body β€” frozen agents get a blue-tinted desaturated body + if agent.is_frozen: + body_color = COLORS["frozen_overlay"] + pygame.draw.circle(self._window, body_color, (cx, cy), pix / 3) + pygame.draw.circle(self._window, color, (cx, cy), pix / 3, width=2) + else: + pygame.draw.circle(self._window, color, (cx, cy), pix / 3) + + # direction indicator + direction = Direction(agent.direction) + end = ( + (agent.position[0] + 0.5 + direction.movement[0] * 0.33) * pix, + (agent.position[1] + 0.5 + direction.movement[1] * 0.33) * pix, + ) + pygame.draw.line(self._window, COLORS["direction_indicator"], (cx, cy), end, 3) + + # label + self._draw_text(agent.entity_id[-1], center=(cx, cy)) + + # health bar (small bar above agent) + bar_w = pix * 0.6 + bar_h = 4 + bar_x = cx - bar_w / 2 + bar_y = cy - pix / 3 - 6 + health_frac = agent.health / agent.max_health if agent.max_health > 0 else 0 + pygame.draw.rect( + self._window, (80, 80, 80), pygame.Rect(bar_x, bar_y, bar_w, bar_h) + ) + pygame.draw.rect( + self._window, + (0, 200, 0), + pygame.Rect(bar_x, bar_y, bar_w * health_frac, bar_h), + ) + + def _draw_base(self, base: Base, pix: float) -> None: + assert self._window is not None + color = _team_color(base.team) + rect = pygame.Rect( + base.position[0] * pix + pix * 0.1, + base.position[1] * pix + pix * 0.1, + pix * 0.8, + pix * 0.8, + ) + + # outline + pygame.draw.rect(self._window, color, rect, width=3) + + # health bar β€” runs along the bottom edge of the outline rect + + health_frac = base.health / base.max_health if base.max_health > 0 else 0.0 + bar_h = max(4, int(pix * 0.08)) + bar_y = rect.bottom - bar_h + # background track (dark) + pygame.draw.rect( + self._window, + (60, 60, 60), + pygame.Rect(rect.left, bar_y, rect.width, bar_h), + ) + # filled portion: green β†’ red as health drops + bar_color = ( + int(255 * (1.0 - health_frac)), # R: rises as health falls + int(200 * health_frac), # G: falls as health falls + 0, + ) + pygame.draw.rect( + self._window, + bar_color, + pygame.Rect(rect.left, bar_y, int(rect.width * health_frac), bar_h), + ) + + # small "B" label + self._draw_text("B", center=(rect.centerx, rect.centery)) + + def _draw_mission(self, mission: Mission, pix: float) -> None: + assert self._window is not None + cx = (mission.position[0] + 0.5) * pix + cy = (mission.position[1] + 0.5) * pix + pygame.draw.circle(self._window, COLORS["mission"], (cx, cy), pix / 6) + + def _draw_recon(self, recon: Recon, pix: float) -> None: + assert self._window is not None + cx = (recon.position[0] + 0.5) * pix + cy = (recon.position[1] + 0.5) * pix + pygame.draw.circle(self._window, COLORS["recon"], (cx, cy), pix / 10) + + def _draw_bomb(self, bomb: Bomb, pix: float) -> None: + """Draw a placed bomb with team colour, shrinking orange fuse, and timer overlay.""" + assert self._window is not None + cx = (bomb.position[0] + 0.5) * pix + cy = (bomb.position[1] + 0.5) * pix + team_color = _team_color(bomb.team) + body_r = pix / 4 + + # Blast-radius outline (square matches Chebyshev blast shape). + r_pix = (bomb.blast_radius + 0.5) * pix + blast_rect = pygame.Rect(cx - r_pix, cy - r_pix, 2 * r_pix, 2 * r_pix) + pygame.draw.rect(self._window, COLORS["bomb_blast"], blast_rect, width=1) + + # Fuse β€” orange line from top of body, length proportional to timer. + # Reference max: 8 ticks covers the typical post-__post_init__ range. + _FUSE_MAX = 8 + fuse_frac = min(1.0, max(0.0, bomb.timer / _FUSE_MAX)) + fuse_max_len = pix * 0.38 + fuse_len = fuse_max_len * fuse_frac + fuse_base = (int(cx), int(cy - body_r)) + if fuse_len >= 1.5: + fuse_tip = (int(cx), int(cy - body_r - fuse_len)) + pygame.draw.line(self._window, (220, 110, 0), fuse_base, fuse_tip, 2) + # Spark at tip: bright yellow dot + pygame.draw.circle(self._window, (255, 240, 60), fuse_tip, 3) + + # Body: team-coloured fill so ownership is instantly obvious. + pygame.draw.circle(self._window, team_color, (cx, cy), body_r) + # Dark border for contrast. + pygame.draw.circle(self._window, COLORS["bomb"], (cx, cy), body_r, width=2) + + # Timer number overlay. + self._draw_text(str(bomb.timer), center=(cx, cy)) + + def _draw_resource(self, resource: Resource, pix: float) -> None: + assert self._window is not None + cx = (resource.position[0] + 0.5) * pix + cy = (resource.position[1] + 0.5) * pix + pygame.draw.circle(self._window, COLORS["resource"], (cx, cy), pix / 8) + + # -- click hit-testing ------------------------------------------------- + + def hit_test( + self, + mouse_x: float, + mouse_y: float, + registry: EntityRegistry, + ): + """Return the topmost entity at pixel coordinates ``(mouse_x, mouse_y)``. + + Checks entities in priority order: agents β†’ bases β†’ beacons β†’ scouts + β†’ missions β†’ recon β†’ powerups. Returns ``None`` if no entity is close + enough to the click. + + Parameters + ---------- + mouse_x, mouse_y: + Pixel coordinates from a ``pygame.MOUSEBUTTONDOWN`` event. + registry: + The live ``EntityRegistry`` for the current episode. + + Returns + ------- + Entity | None + """ + pix = self.window_size / self.grid_size + + def _dist(entity) -> float: + cx = (entity.position[0] + 0.5) * pix + cy = (entity.position[1] + 0.5) * pix + return ((mouse_x - cx) ** 2 + (mouse_y - cy) ** 2) ** 0.5 + + for agent in registry.agents(): + if _dist(agent) <= pix / 3 + 6: + return agent + + for base in registry.bases(): + bx = base.position[0] * pix + pix * 0.1 + by = base.position[1] * pix + pix * 0.1 + if bx <= mouse_x <= bx + pix * 0.8 and by <= mouse_y <= by + pix * 0.8: + return base + + for bomb in registry.bombs(): + if _dist(bomb) <= pix / 4 + 4: + return bomb + + for mission in registry.missions(): + if _dist(mission) <= pix / 6 + 4: + return mission + + for recon in registry.recons(): + if _dist(recon) <= pix / 10 + 4: + return recon + + for resource in registry.resources(): + if _dist(resource) <= pix / 8 + 4: + return resource + + return None + + # -- debug panel -------------------------------------------------------- + + def _draw_debug_panel( + self, + observations: dict[str, dict], + rewards: dict[str, float], + actions: dict[str, int], + num_moves: int, + agent_ids: list[str], + registry: EntityRegistry, + ) -> None: + """Draw the right-hand debug panel with per-agent observations.""" + assert self._window is not None + vc_len, vc_wid = self.viewcone_shape + subpix = int(0.2 * self.window_size / vc_wid) + """ + NOTE: We can the number panels per column to be 4, for the sake of visibility. Hence the coefficient 0.24 used to determine + y_corner. + Then, we do this for 2 columns only. If you need more just edit this function and get a massive screen i guess + """ + cols = chunk_list(agent_ids, 4) + + for i, col in enumerate(cols): + if i >= 2: + break + x_corner = int(self.window_size * (1.04 + 0.50 * i)) + x_lim = int(self.window_size * (1.47 + 0.50 * i)) + for j, agent_id in enumerate(col): + if agent_id is None: + break + obs = observations.get(agent_id) + if obs is None: + continue + + y_corner = int(self.window_size * (0.24 * j + 0.04)) + self._draw_gridlines(vc_len, vc_wid, subpix, x_corner, y_corner) + + # text info + agent_ent = registry.get(agent_id) + hp_str = ( + f"{agent_ent.health:.0f}/{agent_ent.max_health:.0f}" + if isinstance(agent_ent, Agent) + else "?" + ) + # derive team-accurate colors for this agent's viewcone + agent_team = agent_ent.team if isinstance(agent_ent, Agent) else 0 + ally_color = _team_color(agent_team) + enemy_color = _team_color((agent_team + 1) % max(2, self.num_teams)) + for j, text in enumerate( + [ + f"id: {agent_id}", + f"dir: {obs.get('direction', '?')}", + f"hp: {hp_str}", + f"reward: {rewards.get(agent_id, 0):.1f}", + f"loc: {obs.get('location', '?')}", + f"step {num_moves}: act={actions.get(agent_id, '?')}", + ] + ): + self._draw_text(text, topright=(x_lim, y_corner + j * 15)) + + # plot viewcone observation (multi-channel HΓ—WΓ—C tensor) + viewcone = obs.get("agent_viewcone") + if viewcone is not None: + vc_h, vc_w = viewcone.shape[0], viewcone.shape[1] + + # Agent direction needed for both world-pos lookup and wall rotation. + agent_dir = ( + agent_ent.direction + if isinstance(agent_ent, Agent) + else int(Direction.RIGHT) + ) + + # Precompute viewcone-index β†’ world-coord mapping so entity + # colors can be resolved from the registry (correct for any + # number of teams, not just 2). + agent_pos_arr = np.array(obs.get("location", [0, 0])) + vc_to_world: dict[tuple[int, int], tuple[int, int]] = {} + for xi in range(vc_h): + for yi in range(vc_w): + wc = view_to_world( + agent_pos_arr, + Direction(agent_dir), + idx_to_view(np.array([xi, yi]), self.viewcone), + ) + wx, wy = int(wc[0]), int(wc[1]) + if 0 <= wx < self.grid_size and 0 <= wy < self.grid_size: + vc_to_world[(xi, yi)] = (wx, wy) + + for x in range(vc_h): + for y in range(vc_w): + # visibility / tile type + if viewcone[x, y, ViewChannel.VISIBLE] < 0.5: + Tile.NO_VISION.draw( + self._window, x, y, subpix, x_corner, y_corner, True + ) + else: + if viewcone[x, y, ViewChannel.TILE_RECON] > 0.5: + Tile.RECON.draw( + self._window, x, y, subpix, x_corner, y_corner + ) + elif viewcone[x, y, ViewChannel.TILE_MISSION] > 0.5: + Tile.MISSION.draw( + self._window, x, y, subpix, x_corner, y_corner + ) + elif viewcone[x, y, ViewChannel.TILE_RESOURCE] > 0.5: + Tile.RESOURCE.draw( + self._window, x, y, subpix, x_corner, y_corner + ) + + cx = x_corner + (x + 0.5) * subpix + cy = y_corner + (y + 0.5) * subpix + wpos = vc_to_world.get((x, y)) + + if any( + viewcone[x, y, ch] > 0.5 + for ch in ( + ViewChannel.DESTR_WALL_RIGHT, + ViewChannel.DESTR_WALL_DOWN, + ViewChannel.DESTR_WALL_LEFT, + ViewChannel.DESTR_WALL_UP, + ) + ): + pygame.draw.rect( + self._window, + COLORS["destructible_wall"], + pygame.Rect( + x_corner + x * subpix + 1, + y_corner + y * subpix + 1, + subpix - 2, + subpix - 2, + ), + ) + + # Base β€” drawn as a small square in the base's actual team color. + if ( + viewcone[x, y, ViewChannel.ALLY_BASE] > 0.5 + or viewcone[x, y, ViewChannel.ENEMY_BASE] > 0.5 + ): + base_color = ally_color # fallback + if wpos is not None: + for ent in registry.at(*wpos): + if isinstance(ent, Base): + base_color = _team_color(ent.team) + break + elif viewcone[x, y, ViewChannel.ENEMY_BASE] > 0.5: + base_color = enemy_color + side = subpix * 0.55 + pygame.draw.rect( + self._window, + base_color, + pygame.Rect(cx - side / 2, cy - side / 2, side, side), + ) + + # Agent β€” circle in the entity's actual team color. + if ( + viewcone[x, y, ViewChannel.ALLY_AGENT] > 0.5 + or viewcone[x, y, ViewChannel.ENEMY_AGENT] > 0.5 + ): + agent_color = ally_color # fallback + if wpos is not None: + for ent in registry.at(*wpos): + if isinstance(ent, Agent): + agent_color = _team_color(ent.team) + break + elif viewcone[x, y, ViewChannel.ENEMY_AGENT] > 0.5: + agent_color = enemy_color + pygame.draw.circle( + self._window, agent_color, (cx, cy), subpix / 3 + ) + ally_bomb = viewcone[x, y, ViewChannel.ALLY_BOMB] > 0.5 + enemy_bomb = viewcone[x, y, ViewChannel.ENEMY_BOMB] > 0.5 + if ally_bomb or enemy_bomb: + timer_val = int(viewcone[x, y, ViewChannel.ALLY_BOMB_TIMER if ally_bomb else ViewChannel.ENEMY_BOMB_TIMER]) + bomb_r = subpix / 4 + pygame.draw.circle( + self._window, COLORS["bomb"], (cx, cy), bomb_r + ) + pygame.draw.circle( + self._window, COLORS["bomb_blast"], (cx, cy), bomb_r, width=1 + ) + # Mini fuse + _FUSE_MAX = 8 + fuse_frac = min(1.0, max(0.0, timer_val / _FUSE_MAX)) + fuse_len = subpix * 0.3 * fuse_frac + fuse_base = (int(cx), int(cy - bomb_r)) + if fuse_len >= 1: + fuse_tip = (int(cx), int(cy - bomb_r - fuse_len)) + pygame.draw.line( + self._window, (220, 110, 0), fuse_base, fuse_tip, 1 + ) + pygame.draw.circle( + self._window, (255, 240, 60), fuse_tip, 2 + ) + + # Walls pass (drawn on top). + # Wall channels are world-absolute (1=east,2=south,3=west,4=north). + # Rotate by agent direction so walls line up in the display frame. + for x in range(vc_h): + for y in range(vc_w): + for ch in ( + ViewChannel.WALL_RIGHT, + ViewChannel.WALL_DOWN, + ViewChannel.WALL_LEFT, + ViewChannel.WALL_UP, + ): + if viewcone[x, y, ch] > 0.5: + Wall(4 + (ch - 1 - agent_dir) % 4).draw( + self._window, x, y, subpix, x_corner, y_corner + ) diff --git a/til-26-ae-repo/til-26-ae/til_environment/types.py b/til-26-ae-repo/til-26-ae/til_environment/types.py new file mode 100644 index 0000000000000000000000000000000000000000..fca4dd11d28b25f841bac5cef4ce12ca501ee28c --- /dev/null +++ b/til-26-ae-repo/til-26-ae/til_environment/types.py @@ -0,0 +1,218 @@ +from enum import Enum, IntEnum, auto +from typing import TypedDict + +import numpy as np +import pygame + + +class Direction(IntEnum): + RIGHT = 0 + DOWN = 1 + LEFT = 2 + UP = 3 + + @property + def movement(self) -> np.ndarray: + match self: + case Direction.RIGHT: + return np.array([1, 0]) + case Direction.DOWN: + return np.array([0, 1]) + case Direction.LEFT: + return np.array([-1, 0]) + case Direction.UP: + return np.array([0, -1]) + + +class Action(IntEnum): + FORWARD = 0 + BACKWARD = 1 + LEFT = 2 + RIGHT = 3 + STAY = 4 + + +# every tile+player+wall combination is representable by a np.uint8 +class Tile(IntEnum): + NO_VISION = 0 + EMPTY = 1 + RECON = 2 + MISSION = 3 + RESOURCE = 4 + + def draw( + self, + canvas: pygame.Surface, + x: int, + y: int, + square_size: int, + x_corner: int = 0, + y_corner: int = 0, + vision=False, + ): + match self: + case Tile.NO_VISION if vision: + pygame.draw.rect( + canvas, + (80, 80, 80), + pygame.Rect( + x_corner + x * square_size, + y_corner + y * square_size, + square_size, + square_size, + ), + ) + case Tile.RECON: + pygame.draw.circle( + canvas, + (255, 165, 0), + ( + x_corner + (x + 0.5) * square_size, + y_corner + (y + 0.5) * square_size, + ), + square_size / 10, + ) + case Tile.MISSION: + pygame.draw.circle( + canvas, + (147, 112, 219), + ( + x_corner + (x + 0.5) * square_size, + y_corner + (y + 0.5) * square_size, + ), + square_size / 6, + ) + case Tile.RESOURCE: + pygame.draw.circle( + canvas, + (128, 128, 128), + ( + x_corner + (x + 0.5) * square_size, + y_corner + (y + 0.5) * square_size, + ), + square_size / 8, + ) + + +class Player(IntEnum): + # do not exist as tiles in state, only in vision + SCOUT = 2 # 2**2 + GUARD = 3 # 2**3 + + @property + def power(self) -> int: + return 2**self.value + + @property + def color(self) -> tuple[int, int, int]: + match self: + case Player.GUARD: + return (255, 0, 0) + case Player.SCOUT: + return (0, 0, 255) + + def draw( + self, + canvas: pygame.Surface, + x: int, + y: int, + square_size: int, + x_corner: int = 0, + y_corner: int = 0, + ): + pygame.draw.circle( + canvas, + self.color, + (x_corner + (x + 0.5) * square_size, y_corner + (y + 0.5) * square_size), + square_size / 3, + ) + + +class Wall(IntEnum): + RIGHT = 4 # 2**4 = 16 + BOTTOM = 5 # 2**5 = 32 + LEFT = 6 # 2**6 = 64 + TOP = 7 # 2**7 = 128 + + @property + def power(self) -> int: + return 2**self.value + + @property + def orientation(self): + # returns start x, start y, end x, end y + # of the line for the wall to be drawn + match self: + case Wall.RIGHT: + return (1, 0, 1, 1) + case Wall.BOTTOM: + return (0, 1, 1, 1) + case Wall.LEFT: + return (0, 0, 0, 1) + case Wall.TOP: + return (0, 0, 1, 0) + + @property + def end_tile(self): + # returns x, y of the tile on the other side of the wall + match self: + case Wall.RIGHT: + return (1, 0) + case Wall.BOTTOM: + return (0, 1) + case Wall.LEFT: + return (-1, 0) + case Wall.TOP: + return (0, -1) + + def draw( + self, + canvas: pygame.Surface, + x: int, + y: int, + square_size: int, + x_corner: int = 0, + y_corner: int = 0, + width: int = 7, + color=0, + ): + x1, y1, x2, y2 = self.orientation + pygame.draw.line( + canvas, + color, + (x_corner + square_size * (x + x1), y_corner + square_size * (y + y1)), + (x_corner + square_size * (x + x2), y_corner + square_size * (y + y2)), + width=width, + ) + + +class RewardNames(str, Enum): + GUARD_WINS = auto() + GUARD_CAPTURES = auto() + SCOUT_CAPTURED = auto() + SCOUT_RECON = auto() + SCOUT_MISSION = auto() + WALL_COLLISION = auto() + AGENT_COLLIDER = auto() + AGENT_COLLIDEE = auto() + STATIONARY_PENALTY = auto() + GUARD_TRUNCATION = auto() + SCOUT_TRUNCATION = auto() + GUARD_STEP = auto() + SCOUT_STEP = auto() + + +class Observation(TypedDict): + """ + Class representing an observation dictionary from the environment. + + * `viewcone` (np.ndarray): contents of the tile as a bit flag; 0 if not visible + * `direction` (int): direction the agent is facing; see the `Direction` enum + * `scout` (int): 1 if agent is the Scout, 0 otherwise + * `location` (np.ndarray): x,y coordinate of the agent within the world + """ + + viewcone: np.ndarray + direction: int + scout: int + location: np.ndarray diff --git a/til-26-ae-repo/til-26-ae/uv.lock b/til-26-ae-repo/til-26-ae/uv.lock new file mode 100644 index 0000000000000000000000000000000000000000..9ad1a0cafe223d1b9c6481a5b8ddc216af064354 --- /dev/null +++ b/til-26-ae-repo/til-26-ae/uv.lock @@ -0,0 +1,1818 @@ +version = 1 +revision = 3 +requires-python = ">=3.10" +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", + "python_full_version < '3.11'", +] + +[[package]] +name = "antlr4-python3-runtime" +version = "4.9.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/3e/38/7859ff46355f76f8d19459005ca000b6e7012f2f1ca597746cbcd1fbfe5e/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b", size = 117034, upload-time = "2021-11-06T17:52:23.524Z" } + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/35/5d/752690df9ef5b76e169e68d6a129fa6d08a7100ca7f754c89495db3c6019/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee", size = 4170, upload-time = "2024-02-06T09:43:11.258Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/81/29/5ecc3a15d5a33e31b26c11426c45c501e439cb865d0bff96315d86443b78/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c", size = 4321, upload-time = "2024-02-06T09:43:09.663Z" }, +] + +[[package]] +name = "astroid" +version = "4.0.4" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/07/63/0adf26577da5eff6eb7a177876c1cfa213856be9926a000f65c4add9692b/astroid-4.0.4.tar.gz", hash = "sha256:986fed8bcf79fb82c78b18a53352a0b287a73817d6dbcfba3162da36667c49a0", size = 406358, upload-time = "2026-02-07T23:35:07.509Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b0/cf/1c5f42b110e57bc5502eb80dbc3b03d256926062519224835ef08134f1f9/astroid-4.0.4-py3-none-any.whl", hash = "sha256:52f39653876c7dec3e3afd4c2696920e05c83832b9737afc21928f2d2eb7a753", size = 276445, upload-time = "2026-02-07T23:35:05.344Z" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/be/a5/8e3f9b6771b0b408517c82d97aed8f2036509bc247d46114925e32fe33f0/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7", size = 62308, upload-time = "2025-11-15T16:43:48.578Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d2/39/e7eaf1799466a4aef85b6a4fe7bd175ad2b1c6345066aa33f1f58d4b18d0/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a", size = 27047, upload-time = "2025-11-15T16:43:16.109Z" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/93/d7/516d984057745a6cd96575eea814fe1edd6646ee6efd552fb7b0921dec83/cffi-2.0.0-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:0cf2d91ecc3fcc0625c2c530fe004f82c110405f101548512cce44322fa8ac44", size = 184283, upload-time = "2025-09-08T23:22:08.01Z" }, + { url = "https://files.pythonhosted.org/packages/9e/84/ad6a0b408daa859246f57c03efd28e5dd1b33c21737c2db84cae8c237aa5/cffi-2.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f73b96c41e3b2adedc34a7356e64c8eb96e03a3782b535e043a986276ce12a49", size = 180504, upload-time = "2025-09-08T23:22:10.637Z" }, + { url = "https://files.pythonhosted.org/packages/50/bd/b1a6362b80628111e6653c961f987faa55262b4002fcec42308cad1db680/cffi-2.0.0-cp310-cp310-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:53f77cbe57044e88bbd5ed26ac1d0514d2acf0591dd6bb02a3ae37f76811b80c", size = 208811, upload-time = "2025-09-08T23:22:12.267Z" }, + { url = "https://files.pythonhosted.org/packages/4f/27/6933a8b2562d7bd1fb595074cf99cc81fc3789f6a6c05cdabb46284a3188/cffi-2.0.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:3e837e369566884707ddaf85fc1744b47575005c0a229de3327f8f9a20f4efeb", size = 216402, upload-time = "2025-09-08T23:22:13.455Z" }, + { url = "https://files.pythonhosted.org/packages/05/eb/b86f2a2645b62adcfff53b0dd97e8dfafb5c8aa864bd0d9a2c2049a0d551/cffi-2.0.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:5eda85d6d1879e692d546a078b44251cdd08dd1cfb98dfb77b670c97cee49ea0", size = 203217, upload-time = "2025-09-08T23:22:14.596Z" }, + { url = "https://files.pythonhosted.org/packages/9f/e0/6cbe77a53acf5acc7c08cc186c9928864bd7c005f9efd0d126884858a5fe/cffi-2.0.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9332088d75dc3241c702d852d4671613136d90fa6881da7d770a483fd05248b4", size = 203079, upload-time = "2025-09-08T23:22:15.769Z" }, + { url = "https://files.pythonhosted.org/packages/98/29/9b366e70e243eb3d14a5cb488dfd3a0b6b2f1fb001a203f653b93ccfac88/cffi-2.0.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc7de24befaeae77ba923797c7c87834c73648a05a4bde34b3b7e5588973a453", size = 216475, upload-time = "2025-09-08T23:22:17.427Z" }, + { url = "https://files.pythonhosted.org/packages/21/7a/13b24e70d2f90a322f2900c5d8e1f14fa7e2a6b3332b7309ba7b2ba51a5a/cffi-2.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cf364028c016c03078a23b503f02058f1814320a56ad535686f90565636a9495", size = 218829, upload-time = "2025-09-08T23:22:19.069Z" }, + { url = "https://files.pythonhosted.org/packages/60/99/c9dc110974c59cc981b1f5b66e1d8af8af764e00f0293266824d9c4254bc/cffi-2.0.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e11e82b744887154b182fd3e7e8512418446501191994dbf9c9fc1f32cc8efd5", size = 211211, upload-time = "2025-09-08T23:22:20.588Z" }, + { url = "https://files.pythonhosted.org/packages/49/72/ff2d12dbf21aca1b32a40ed792ee6b40f6dc3a9cf1644bd7ef6e95e0ac5e/cffi-2.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8ea985900c5c95ce9db1745f7933eeef5d314f0565b27625d9a10ec9881e1bfb", size = 218036, upload-time = "2025-09-08T23:22:22.143Z" }, + { url = "https://files.pythonhosted.org/packages/e2/cc/027d7fb82e58c48ea717149b03bcadcbdc293553edb283af792bd4bcbb3f/cffi-2.0.0-cp310-cp310-win32.whl", hash = "sha256:1f72fb8906754ac8a2cc3f9f5aaa298070652a0ffae577e0ea9bd480dc3c931a", size = 172184, upload-time = "2025-09-08T23:22:23.328Z" }, + { url = "https://files.pythonhosted.org/packages/33/fa/072dd15ae27fbb4e06b437eb6e944e75b068deb09e2a2826039e49ee2045/cffi-2.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:b18a3ed7d5b3bd8d9ef7a8cb226502c6bf8308df1525e1cc676c3680e7176739", size = 182790, upload-time = "2025-09-08T23:22:24.752Z" }, + { url = "https://files.pythonhosted.org/packages/12/4a/3dfd5f7850cbf0d06dc84ba9aa00db766b52ca38d8b86e3a38314d52498c/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe", size = 184344, upload-time = "2025-09-08T23:22:26.456Z" }, + { url = "https://files.pythonhosted.org/packages/4f/8b/f0e4c441227ba756aafbe78f117485b25bb26b1c059d01f137fa6d14896b/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c", size = 180560, upload-time = "2025-09-08T23:22:28.197Z" }, + { url = "https://files.pythonhosted.org/packages/b1/b7/1200d354378ef52ec227395d95c2576330fd22a869f7a70e88e1447eb234/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92", size = 209613, upload-time = "2025-09-08T23:22:29.475Z" }, + { url = "https://files.pythonhosted.org/packages/b8/56/6033f5e86e8cc9bb629f0077ba71679508bdf54a9a5e112a3c0b91870332/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93", size = 216476, upload-time = "2025-09-08T23:22:31.063Z" }, + { url = "https://files.pythonhosted.org/packages/dc/7f/55fecd70f7ece178db2f26128ec41430d8720f2d12ca97bf8f0a628207d5/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5", size = 203374, upload-time = "2025-09-08T23:22:32.507Z" }, + { url = "https://files.pythonhosted.org/packages/84/ef/a7b77c8bdc0f77adc3b46888f1ad54be8f3b7821697a7b89126e829e676a/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664", size = 202597, upload-time = "2025-09-08T23:22:34.132Z" }, + { url = "https://files.pythonhosted.org/packages/d7/91/500d892b2bf36529a75b77958edfcd5ad8e2ce4064ce2ecfeab2125d72d1/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26", size = 215574, upload-time = "2025-09-08T23:22:35.443Z" }, + { url = "https://files.pythonhosted.org/packages/44/64/58f6255b62b101093d5df22dcb752596066c7e89dd725e0afaed242a61be/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9", size = 218971, upload-time = "2025-09-08T23:22:36.805Z" }, + { url = "https://files.pythonhosted.org/packages/ab/49/fa72cebe2fd8a55fbe14956f9970fe8eb1ac59e5df042f603ef7c8ba0adc/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414", size = 211972, upload-time = "2025-09-08T23:22:38.436Z" }, + { url = "https://files.pythonhosted.org/packages/0b/28/dd0967a76aab36731b6ebfe64dec4e981aff7e0608f60c2d46b46982607d/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743", size = 217078, upload-time = "2025-09-08T23:22:39.776Z" }, + { url = "https://files.pythonhosted.org/packages/2b/c0/015b25184413d7ab0a410775fdb4a50fca20f5589b5dab1dbbfa3baad8ce/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5", size = 172076, upload-time = "2025-09-08T23:22:40.95Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8f/dc5531155e7070361eb1b7e4c1a9d896d0cb21c49f807a6c03fd63fc877e/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5", size = 182820, upload-time = "2025-09-08T23:22:42.463Z" }, + { url = "https://files.pythonhosted.org/packages/95/5c/1b493356429f9aecfd56bc171285a4c4ac8697f76e9bbbbb105e537853a1/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d", size = 177635, upload-time = "2025-09-08T23:22:43.623Z" }, + { url = "https://files.pythonhosted.org/packages/ea/47/4f61023ea636104d4f16ab488e268b93008c3d0bb76893b1b31db1f96802/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d", size = 185271, upload-time = "2025-09-08T23:22:44.795Z" }, + { url = "https://files.pythonhosted.org/packages/df/a2/781b623f57358e360d62cdd7a8c681f074a71d445418a776eef0aadb4ab4/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c", size = 181048, upload-time = "2025-09-08T23:22:45.938Z" }, + { url = "https://files.pythonhosted.org/packages/ff/df/a4f0fbd47331ceeba3d37c2e51e9dfc9722498becbeec2bd8bc856c9538a/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe", size = 212529, upload-time = "2025-09-08T23:22:47.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/72/12b5f8d3865bf0f87cf1404d8c374e7487dcf097a1c91c436e72e6badd83/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062", size = 220097, upload-time = "2025-09-08T23:22:48.677Z" }, + { url = "https://files.pythonhosted.org/packages/c2/95/7a135d52a50dfa7c882ab0ac17e8dc11cec9d55d2c18dda414c051c5e69e/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e", size = 207983, upload-time = "2025-09-08T23:22:50.06Z" }, + { url = "https://files.pythonhosted.org/packages/3a/c8/15cb9ada8895957ea171c62dc78ff3e99159ee7adb13c0123c001a2546c1/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037", size = 206519, upload-time = "2025-09-08T23:22:51.364Z" }, + { url = "https://files.pythonhosted.org/packages/78/2d/7fa73dfa841b5ac06c7b8855cfc18622132e365f5b81d02230333ff26e9e/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba", size = 219572, upload-time = "2025-09-08T23:22:52.902Z" }, + { url = "https://files.pythonhosted.org/packages/07/e0/267e57e387b4ca276b90f0434ff88b2c2241ad72b16d31836adddfd6031b/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94", size = 222963, upload-time = "2025-09-08T23:22:54.518Z" }, + { url = "https://files.pythonhosted.org/packages/b6/75/1f2747525e06f53efbd878f4d03bac5b859cbc11c633d0fb81432d98a795/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187", size = 221361, upload-time = "2025-09-08T23:22:55.867Z" }, + { url = "https://files.pythonhosted.org/packages/7b/2b/2b6435f76bfeb6bbf055596976da087377ede68df465419d192acf00c437/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18", size = 172932, upload-time = "2025-09-08T23:22:57.188Z" }, + { url = "https://files.pythonhosted.org/packages/f8/ed/13bd4418627013bec4ed6e54283b1959cf6db888048c7cf4b4c3b5b36002/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5", size = 183557, upload-time = "2025-09-08T23:22:58.351Z" }, + { url = "https://files.pythonhosted.org/packages/95/31/9f7f93ad2f8eff1dbc1c3656d7ca5bfd8fb52c9d786b4dcf19b2d02217fa/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6", size = 177762, upload-time = "2025-09-08T23:22:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/4b/8d/a0a47a0c9e413a658623d014e91e74a50cdd2c423f7ccfd44086ef767f90/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb", size = 185230, upload-time = "2025-09-08T23:23:00.879Z" }, + { url = "https://files.pythonhosted.org/packages/4a/d2/a6c0296814556c68ee32009d9c2ad4f85f2707cdecfd7727951ec228005d/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca", size = 181043, upload-time = "2025-09-08T23:23:02.231Z" }, + { url = "https://files.pythonhosted.org/packages/b0/1e/d22cc63332bd59b06481ceaac49d6c507598642e2230f201649058a7e704/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b", size = 212446, upload-time = "2025-09-08T23:23:03.472Z" }, + { url = "https://files.pythonhosted.org/packages/a9/f5/a2c23eb03b61a0b8747f211eb716446c826ad66818ddc7810cc2cc19b3f2/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b", size = 220101, upload-time = "2025-09-08T23:23:04.792Z" }, + { url = "https://files.pythonhosted.org/packages/f2/7f/e6647792fc5850d634695bc0e6ab4111ae88e89981d35ac269956605feba/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2", size = 207948, upload-time = "2025-09-08T23:23:06.127Z" }, + { url = "https://files.pythonhosted.org/packages/cb/1e/a5a1bd6f1fb30f22573f76533de12a00bf274abcdc55c8edab639078abb6/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3", size = 206422, upload-time = "2025-09-08T23:23:07.753Z" }, + { url = "https://files.pythonhosted.org/packages/98/df/0a1755e750013a2081e863e7cd37e0cdd02664372c754e5560099eb7aa44/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26", size = 219499, upload-time = "2025-09-08T23:23:09.648Z" }, + { url = "https://files.pythonhosted.org/packages/50/e1/a969e687fcf9ea58e6e2a928ad5e2dd88cc12f6f0ab477e9971f2309b57c/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c", size = 222928, upload-time = "2025-09-08T23:23:10.928Z" }, + { url = "https://files.pythonhosted.org/packages/36/54/0362578dd2c9e557a28ac77698ed67323ed5b9775ca9d3fe73fe191bb5d8/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b", size = 221302, upload-time = "2025-09-08T23:23:12.42Z" }, + { url = "https://files.pythonhosted.org/packages/eb/6d/bf9bda840d5f1dfdbf0feca87fbdb64a918a69bca42cfa0ba7b137c48cb8/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27", size = 172909, upload-time = "2025-09-08T23:23:14.32Z" }, + { url = "https://files.pythonhosted.org/packages/37/18/6519e1ee6f5a1e579e04b9ddb6f1676c17368a7aba48299c3759bbc3c8b3/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75", size = 183402, upload-time = "2025-09-08T23:23:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/cb/0e/02ceeec9a7d6ee63bb596121c2c8e9b3a9e150936f4fbef6ca1943e6137c/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91", size = 177780, upload-time = "2025-09-08T23:23:16.761Z" }, + { url = "https://files.pythonhosted.org/packages/92/c4/3ce07396253a83250ee98564f8d7e9789fab8e58858f35d07a9a2c78de9f/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5", size = 185320, upload-time = "2025-09-08T23:23:18.087Z" }, + { url = "https://files.pythonhosted.org/packages/59/dd/27e9fa567a23931c838c6b02d0764611c62290062a6d4e8ff7863daf9730/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13", size = 181487, upload-time = "2025-09-08T23:23:19.622Z" }, + { url = "https://files.pythonhosted.org/packages/d6/43/0e822876f87ea8a4ef95442c3d766a06a51fc5298823f884ef87aaad168c/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b", size = 220049, upload-time = "2025-09-08T23:23:20.853Z" }, + { url = "https://files.pythonhosted.org/packages/b4/89/76799151d9c2d2d1ead63c2429da9ea9d7aac304603de0c6e8764e6e8e70/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c", size = 207793, upload-time = "2025-09-08T23:23:22.08Z" }, + { url = "https://files.pythonhosted.org/packages/bb/dd/3465b14bb9e24ee24cb88c9e3730f6de63111fffe513492bf8c808a3547e/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef", size = 206300, upload-time = "2025-09-08T23:23:23.314Z" }, + { url = "https://files.pythonhosted.org/packages/47/d9/d83e293854571c877a92da46fdec39158f8d7e68da75bf73581225d28e90/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775", size = 219244, upload-time = "2025-09-08T23:23:24.541Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0f/1f177e3683aead2bb00f7679a16451d302c436b5cbf2505f0ea8146ef59e/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205", size = 222828, upload-time = "2025-09-08T23:23:26.143Z" }, + { url = "https://files.pythonhosted.org/packages/c6/0f/cafacebd4b040e3119dcb32fed8bdef8dfe94da653155f9d0b9dc660166e/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1", size = 220926, upload-time = "2025-09-08T23:23:27.873Z" }, + { url = "https://files.pythonhosted.org/packages/3e/aa/df335faa45b395396fcbc03de2dfcab242cd61a9900e914fe682a59170b1/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f", size = 175328, upload-time = "2025-09-08T23:23:44.61Z" }, + { url = "https://files.pythonhosted.org/packages/bb/92/882c2d30831744296ce713f0feb4c1cd30f346ef747b530b5318715cc367/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25", size = 185650, upload-time = "2025-09-08T23:23:45.848Z" }, + { url = "https://files.pythonhosted.org/packages/9f/2c/98ece204b9d35a7366b5b2c6539c350313ca13932143e79dc133ba757104/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad", size = 180687, upload-time = "2025-09-08T23:23:47.105Z" }, + { url = "https://files.pythonhosted.org/packages/3e/61/c768e4d548bfa607abcda77423448df8c471f25dbe64fb2ef6d555eae006/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9", size = 188773, upload-time = "2025-09-08T23:23:29.347Z" }, + { url = "https://files.pythonhosted.org/packages/2c/ea/5f76bce7cf6fcd0ab1a1058b5af899bfbef198bea4d5686da88471ea0336/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d", size = 185013, upload-time = "2025-09-08T23:23:30.63Z" }, + { url = "https://files.pythonhosted.org/packages/be/b4/c56878d0d1755cf9caa54ba71e5d049479c52f9e4afc230f06822162ab2f/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c", size = 221593, upload-time = "2025-09-08T23:23:31.91Z" }, + { url = "https://files.pythonhosted.org/packages/e0/0d/eb704606dfe8033e7128df5e90fee946bbcb64a04fcdaa97321309004000/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8", size = 209354, upload-time = "2025-09-08T23:23:33.214Z" }, + { url = "https://files.pythonhosted.org/packages/d8/19/3c435d727b368ca475fb8742ab97c9cb13a0de600ce86f62eab7fa3eea60/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc", size = 208480, upload-time = "2025-09-08T23:23:34.495Z" }, + { url = "https://files.pythonhosted.org/packages/d0/44/681604464ed9541673e486521497406fadcc15b5217c3e326b061696899a/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592", size = 221584, upload-time = "2025-09-08T23:23:36.096Z" }, + { url = "https://files.pythonhosted.org/packages/25/8e/342a504ff018a2825d395d44d63a767dd8ebc927ebda557fecdaca3ac33a/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512", size = 224443, upload-time = "2025-09-08T23:23:37.328Z" }, + { url = "https://files.pythonhosted.org/packages/e1/5e/b666bacbbc60fbf415ba9988324a132c9a7a0448a9a8f125074671c0f2c3/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4", size = 223437, upload-time = "2025-09-08T23:23:38.945Z" }, + { url = "https://files.pythonhosted.org/packages/a0/1d/ec1a60bd1a10daa292d3cd6bb0b359a81607154fb8165f3ec95fe003b85c/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e", size = 180487, upload-time = "2025-09-08T23:23:40.423Z" }, + { url = "https://files.pythonhosted.org/packages/bf/41/4c1168c74fac325c0c8156f04b6749c8b6a8f405bbf91413ba088359f60d/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6", size = 191726, upload-time = "2025-09-08T23:23:41.742Z" }, + { url = "https://files.pythonhosted.org/packages/ae/3a/dbeec9d1ee0844c679f6bb5d6ad4e9f198b1224f4e7a32825f47f6192b0c/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9", size = 184195, upload-time = "2025-09-08T23:23:43.004Z" }, +] + +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4c/13/7d740c5849255756bc17888787313b61fd38a0a8304fc4f073dfc46122aa/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971", size = 6319, upload-time = "2025-07-25T14:02:04.452Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/60/97/891a0971e1e4a8c5d2b20bbe0e524dc04548d2307fee33cdeba148fd4fc7/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417", size = 7294, upload-time = "2025-07-25T14:02:02.896Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.2" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/54/eb9bfc647b19f2009dd5c7f5ec51c4e6ca831725f1aea7a993034f483147/contourpy-1.3.2.tar.gz", hash = "sha256:b6945942715a034c671b7fc54f9588126b0b8bf23db2696e3ca8328f3ff0ab54", size = 13466130, upload-time = "2025-04-15T17:47:53.79Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/12/a3/da4153ec8fe25d263aa48c1a4cbde7f49b59af86f0b6f7862788c60da737/contourpy-1.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba38e3f9f330af820c4b27ceb4b9c7feee5fe0493ea53a8720f4792667465934", size = 268551, upload-time = "2025-04-15T17:34:46.581Z" }, + { url = "https://files.pythonhosted.org/packages/2f/6c/330de89ae1087eb622bfca0177d32a7ece50c3ef07b28002de4757d9d875/contourpy-1.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:dc41ba0714aa2968d1f8674ec97504a8f7e334f48eeacebcaa6256213acb0989", size = 253399, upload-time = "2025-04-15T17:34:51.427Z" }, + { url = "https://files.pythonhosted.org/packages/c1/bd/20c6726b1b7f81a8bee5271bed5c165f0a8e1f572578a9d27e2ccb763cb2/contourpy-1.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9be002b31c558d1ddf1b9b415b162c603405414bacd6932d031c5b5a8b757f0d", size = 312061, upload-time = "2025-04-15T17:34:55.961Z" }, + { url = "https://files.pythonhosted.org/packages/22/fc/a9665c88f8a2473f823cf1ec601de9e5375050f1958cbb356cdf06ef1ab6/contourpy-1.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8d2e74acbcba3bfdb6d9d8384cdc4f9260cae86ed9beee8bd5f54fee49a430b9", size = 351956, upload-time = "2025-04-15T17:35:00.992Z" }, + { url = "https://files.pythonhosted.org/packages/25/eb/9f0a0238f305ad8fb7ef42481020d6e20cf15e46be99a1fcf939546a177e/contourpy-1.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e259bced5549ac64410162adc973c5e2fb77f04df4a439d00b478e57a0e65512", size = 320872, upload-time = "2025-04-15T17:35:06.177Z" }, + { url = "https://files.pythonhosted.org/packages/32/5c/1ee32d1c7956923202f00cf8d2a14a62ed7517bdc0ee1e55301227fc273c/contourpy-1.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad687a04bc802cbe8b9c399c07162a3c35e227e2daccf1668eb1f278cb698631", size = 325027, upload-time = "2025-04-15T17:35:11.244Z" }, + { url = "https://files.pythonhosted.org/packages/83/bf/9baed89785ba743ef329c2b07fd0611d12bfecbedbdd3eeecf929d8d3b52/contourpy-1.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cdd22595308f53ef2f891040ab2b93d79192513ffccbd7fe19be7aa773a5e09f", size = 1306641, upload-time = "2025-04-15T17:35:26.701Z" }, + { url = "https://files.pythonhosted.org/packages/d4/cc/74e5e83d1e35de2d28bd97033426b450bc4fd96e092a1f7a63dc7369b55d/contourpy-1.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b4f54d6a2defe9f257327b0f243612dd051cc43825587520b1bf74a31e2f6ef2", size = 1374075, upload-time = "2025-04-15T17:35:43.204Z" }, + { url = "https://files.pythonhosted.org/packages/0c/42/17f3b798fd5e033b46a16f8d9fcb39f1aba051307f5ebf441bad1ecf78f8/contourpy-1.3.2-cp310-cp310-win32.whl", hash = "sha256:f939a054192ddc596e031e50bb13b657ce318cf13d264f095ce9db7dc6ae81c0", size = 177534, upload-time = "2025-04-15T17:35:46.554Z" }, + { url = "https://files.pythonhosted.org/packages/54/ec/5162b8582f2c994721018d0c9ece9dc6ff769d298a8ac6b6a652c307e7df/contourpy-1.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:c440093bbc8fc21c637c03bafcbef95ccd963bc6e0514ad887932c18ca2a759a", size = 221188, upload-time = "2025-04-15T17:35:50.064Z" }, + { url = "https://files.pythonhosted.org/packages/b3/b9/ede788a0b56fc5b071639d06c33cb893f68b1178938f3425debebe2dab78/contourpy-1.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6a37a2fb93d4df3fc4c0e363ea4d16f83195fc09c891bc8ce072b9d084853445", size = 269636, upload-time = "2025-04-15T17:35:54.473Z" }, + { url = "https://files.pythonhosted.org/packages/e6/75/3469f011d64b8bbfa04f709bfc23e1dd71be54d05b1b083be9f5b22750d1/contourpy-1.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b7cd50c38f500bbcc9b6a46643a40e0913673f869315d8e70de0438817cb7773", size = 254636, upload-time = "2025-04-15T17:35:58.283Z" }, + { url = "https://files.pythonhosted.org/packages/8d/2f/95adb8dae08ce0ebca4fd8e7ad653159565d9739128b2d5977806656fcd2/contourpy-1.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d6658ccc7251a4433eebd89ed2672c2ed96fba367fd25ca9512aa92a4b46c4f1", size = 313053, upload-time = "2025-04-15T17:36:03.235Z" }, + { url = "https://files.pythonhosted.org/packages/c3/a6/8ccf97a50f31adfa36917707fe39c9a0cbc24b3bbb58185577f119736cc9/contourpy-1.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:70771a461aaeb335df14deb6c97439973d253ae70660ca085eec25241137ef43", size = 352985, upload-time = "2025-04-15T17:36:08.275Z" }, + { url = "https://files.pythonhosted.org/packages/1d/b6/7925ab9b77386143f39d9c3243fdd101621b4532eb126743201160ffa7e6/contourpy-1.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65a887a6e8c4cd0897507d814b14c54a8c2e2aa4ac9f7686292f9769fcf9a6ab", size = 323750, upload-time = "2025-04-15T17:36:13.29Z" }, + { url = "https://files.pythonhosted.org/packages/c2/f3/20c5d1ef4f4748e52d60771b8560cf00b69d5c6368b5c2e9311bcfa2a08b/contourpy-1.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3859783aefa2b8355697f16642695a5b9792e7a46ab86da1118a4a23a51a33d7", size = 326246, upload-time = "2025-04-15T17:36:18.329Z" }, + { url = "https://files.pythonhosted.org/packages/8c/e5/9dae809e7e0b2d9d70c52b3d24cba134dd3dad979eb3e5e71f5df22ed1f5/contourpy-1.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:eab0f6db315fa4d70f1d8ab514e527f0366ec021ff853d7ed6a2d33605cf4b83", size = 1308728, upload-time = "2025-04-15T17:36:33.878Z" }, + { url = "https://files.pythonhosted.org/packages/e2/4a/0058ba34aeea35c0b442ae61a4f4d4ca84d6df8f91309bc2d43bb8dd248f/contourpy-1.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d91a3ccc7fea94ca0acab82ceb77f396d50a1f67412efe4c526f5d20264e6ecd", size = 1375762, upload-time = "2025-04-15T17:36:51.295Z" }, + { url = "https://files.pythonhosted.org/packages/09/33/7174bdfc8b7767ef2c08ed81244762d93d5c579336fc0b51ca57b33d1b80/contourpy-1.3.2-cp311-cp311-win32.whl", hash = "sha256:1c48188778d4d2f3d48e4643fb15d8608b1d01e4b4d6b0548d9b336c28fc9b6f", size = 178196, upload-time = "2025-04-15T17:36:55.002Z" }, + { url = "https://files.pythonhosted.org/packages/5e/fe/4029038b4e1c4485cef18e480b0e2cd2d755448bb071eb9977caac80b77b/contourpy-1.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:5ebac872ba09cb8f2131c46b8739a7ff71de28a24c869bcad554477eb089a878", size = 222017, upload-time = "2025-04-15T17:36:58.576Z" }, + { url = "https://files.pythonhosted.org/packages/34/f7/44785876384eff370c251d58fd65f6ad7f39adce4a093c934d4a67a7c6b6/contourpy-1.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4caf2bcd2969402bf77edc4cb6034c7dd7c0803213b3523f111eb7460a51b8d2", size = 271580, upload-time = "2025-04-15T17:37:03.105Z" }, + { url = "https://files.pythonhosted.org/packages/93/3b/0004767622a9826ea3d95f0e9d98cd8729015768075d61f9fea8eeca42a8/contourpy-1.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:82199cb78276249796419fe36b7386bd8d2cc3f28b3bc19fe2454fe2e26c4c15", size = 255530, upload-time = "2025-04-15T17:37:07.026Z" }, + { url = "https://files.pythonhosted.org/packages/e7/bb/7bd49e1f4fa805772d9fd130e0d375554ebc771ed7172f48dfcd4ca61549/contourpy-1.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:106fab697af11456fcba3e352ad50effe493a90f893fca6c2ca5c033820cea92", size = 307688, upload-time = "2025-04-15T17:37:11.481Z" }, + { url = "https://files.pythonhosted.org/packages/fc/97/e1d5dbbfa170725ef78357a9a0edc996b09ae4af170927ba8ce977e60a5f/contourpy-1.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d14f12932a8d620e307f715857107b1d1845cc44fdb5da2bc8e850f5ceba9f87", size = 347331, upload-time = "2025-04-15T17:37:18.212Z" }, + { url = "https://files.pythonhosted.org/packages/6f/66/e69e6e904f5ecf6901be3dd16e7e54d41b6ec6ae3405a535286d4418ffb4/contourpy-1.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:532fd26e715560721bb0d5fc7610fce279b3699b018600ab999d1be895b09415", size = 318963, upload-time = "2025-04-15T17:37:22.76Z" }, + { url = "https://files.pythonhosted.org/packages/a8/32/b8a1c8965e4f72482ff2d1ac2cd670ce0b542f203c8e1d34e7c3e6925da7/contourpy-1.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b383144cf2d2c29f01a1e8170f50dacf0eac02d64139dcd709a8ac4eb3cfe", size = 323681, upload-time = "2025-04-15T17:37:33.001Z" }, + { url = "https://files.pythonhosted.org/packages/30/c6/12a7e6811d08757c7162a541ca4c5c6a34c0f4e98ef2b338791093518e40/contourpy-1.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c49f73e61f1f774650a55d221803b101d966ca0c5a2d6d5e4320ec3997489441", size = 1308674, upload-time = "2025-04-15T17:37:48.64Z" }, + { url = "https://files.pythonhosted.org/packages/2a/8a/bebe5a3f68b484d3a2b8ffaf84704b3e343ef1addea528132ef148e22b3b/contourpy-1.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3d80b2c0300583228ac98d0a927a1ba6a2ba6b8a742463c564f1d419ee5b211e", size = 1380480, upload-time = "2025-04-15T17:38:06.7Z" }, + { url = "https://files.pythonhosted.org/packages/34/db/fcd325f19b5978fb509a7d55e06d99f5f856294c1991097534360b307cf1/contourpy-1.3.2-cp312-cp312-win32.whl", hash = "sha256:90df94c89a91b7362e1142cbee7568f86514412ab8a2c0d0fca72d7e91b62912", size = 178489, upload-time = "2025-04-15T17:38:10.338Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/fadd0b92ffa7b5eb5949bf340a63a4a496a6930a6c37a7ba0f12acb076d6/contourpy-1.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:8c942a01d9163e2e5cfb05cb66110121b8d07ad438a17f9e766317bcb62abf73", size = 223042, upload-time = "2025-04-15T17:38:14.239Z" }, + { url = "https://files.pythonhosted.org/packages/2e/61/5673f7e364b31e4e7ef6f61a4b5121c5f170f941895912f773d95270f3a2/contourpy-1.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:de39db2604ae755316cb5967728f4bea92685884b1e767b7c24e983ef5f771cb", size = 271630, upload-time = "2025-04-15T17:38:19.142Z" }, + { url = "https://files.pythonhosted.org/packages/ff/66/a40badddd1223822c95798c55292844b7e871e50f6bfd9f158cb25e0bd39/contourpy-1.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3f9e896f447c5c8618f1edb2bafa9a4030f22a575ec418ad70611450720b5b08", size = 255670, upload-time = "2025-04-15T17:38:23.688Z" }, + { url = "https://files.pythonhosted.org/packages/1e/c7/cf9fdee8200805c9bc3b148f49cb9482a4e3ea2719e772602a425c9b09f8/contourpy-1.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71e2bd4a1c4188f5c2b8d274da78faab884b59df20df63c34f74aa1813c4427c", size = 306694, upload-time = "2025-04-15T17:38:28.238Z" }, + { url = "https://files.pythonhosted.org/packages/dd/e7/ccb9bec80e1ba121efbffad7f38021021cda5be87532ec16fd96533bb2e0/contourpy-1.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de425af81b6cea33101ae95ece1f696af39446db9682a0b56daaa48cfc29f38f", size = 345986, upload-time = "2025-04-15T17:38:33.502Z" }, + { url = "https://files.pythonhosted.org/packages/dc/49/ca13bb2da90391fa4219fdb23b078d6065ada886658ac7818e5441448b78/contourpy-1.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:977e98a0e0480d3fe292246417239d2d45435904afd6d7332d8455981c408b85", size = 318060, upload-time = "2025-04-15T17:38:38.672Z" }, + { url = "https://files.pythonhosted.org/packages/c8/65/5245ce8c548a8422236c13ffcdcdada6a2a812c361e9e0c70548bb40b661/contourpy-1.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:434f0adf84911c924519d2b08fc10491dd282b20bdd3fa8f60fd816ea0b48841", size = 322747, upload-time = "2025-04-15T17:38:43.712Z" }, + { url = "https://files.pythonhosted.org/packages/72/30/669b8eb48e0a01c660ead3752a25b44fdb2e5ebc13a55782f639170772f9/contourpy-1.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c66c4906cdbc50e9cba65978823e6e00b45682eb09adbb78c9775b74eb222422", size = 1308895, upload-time = "2025-04-15T17:39:00.224Z" }, + { url = "https://files.pythonhosted.org/packages/05/5a/b569f4250decee6e8d54498be7bdf29021a4c256e77fe8138c8319ef8eb3/contourpy-1.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8b7fc0cd78ba2f4695fd0a6ad81a19e7e3ab825c31b577f384aa9d7817dc3bef", size = 1379098, upload-time = "2025-04-15T17:43:29.649Z" }, + { url = "https://files.pythonhosted.org/packages/19/ba/b227c3886d120e60e41b28740ac3617b2f2b971b9f601c835661194579f1/contourpy-1.3.2-cp313-cp313-win32.whl", hash = "sha256:15ce6ab60957ca74cff444fe66d9045c1fd3e92c8936894ebd1f3eef2fff075f", size = 178535, upload-time = "2025-04-15T17:44:44.532Z" }, + { url = "https://files.pythonhosted.org/packages/12/6e/2fed56cd47ca739b43e892707ae9a13790a486a3173be063681ca67d2262/contourpy-1.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:e1578f7eafce927b168752ed7e22646dad6cd9bca673c60bff55889fa236ebf9", size = 223096, upload-time = "2025-04-15T17:44:48.194Z" }, + { url = "https://files.pythonhosted.org/packages/54/4c/e76fe2a03014a7c767d79ea35c86a747e9325537a8b7627e0e5b3ba266b4/contourpy-1.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0475b1f6604896bc7c53bb070e355e9321e1bc0d381735421a2d2068ec56531f", size = 285090, upload-time = "2025-04-15T17:43:34.084Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e2/5aba47debd55d668e00baf9651b721e7733975dc9fc27264a62b0dd26eb8/contourpy-1.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c85bb486e9be652314bb5b9e2e3b0d1b2e643d5eec4992c0fbe8ac71775da739", size = 268643, upload-time = "2025-04-15T17:43:38.626Z" }, + { url = "https://files.pythonhosted.org/packages/a1/37/cd45f1f051fe6230f751cc5cdd2728bb3a203f5619510ef11e732109593c/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:745b57db7758f3ffc05a10254edd3182a2a83402a89c00957a8e8a22f5582823", size = 310443, upload-time = "2025-04-15T17:43:44.522Z" }, + { url = "https://files.pythonhosted.org/packages/8b/a2/36ea6140c306c9ff6dd38e3bcec80b3b018474ef4d17eb68ceecd26675f4/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:970e9173dbd7eba9b4e01aab19215a48ee5dd3f43cef736eebde064a171f89a5", size = 349865, upload-time = "2025-04-15T17:43:49.545Z" }, + { url = "https://files.pythonhosted.org/packages/95/b7/2fc76bc539693180488f7b6cc518da7acbbb9e3b931fd9280504128bf956/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c6c4639a9c22230276b7bffb6a850dfc8258a2521305e1faefe804d006b2e532", size = 321162, upload-time = "2025-04-15T17:43:54.203Z" }, + { url = "https://files.pythonhosted.org/packages/f4/10/76d4f778458b0aa83f96e59d65ece72a060bacb20cfbee46cf6cd5ceba41/contourpy-1.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc829960f34ba36aad4302e78eabf3ef16a3a100863f0d4eeddf30e8a485a03b", size = 327355, upload-time = "2025-04-15T17:44:01.025Z" }, + { url = "https://files.pythonhosted.org/packages/43/a3/10cf483ea683f9f8ab096c24bad3cce20e0d1dd9a4baa0e2093c1c962d9d/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:d32530b534e986374fc19eaa77fcb87e8a99e5431499949b828312bdcd20ac52", size = 1307935, upload-time = "2025-04-15T17:44:17.322Z" }, + { url = "https://files.pythonhosted.org/packages/78/73/69dd9a024444489e22d86108e7b913f3528f56cfc312b5c5727a44188471/contourpy-1.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e298e7e70cf4eb179cc1077be1c725b5fd131ebc81181bf0c03525c8abc297fd", size = 1372168, upload-time = "2025-04-15T17:44:33.43Z" }, + { url = "https://files.pythonhosted.org/packages/0f/1b/96d586ccf1b1a9d2004dd519b25fbf104a11589abfd05484ff12199cca21/contourpy-1.3.2-cp313-cp313t-win32.whl", hash = "sha256:d0e589ae0d55204991450bb5c23f571c64fe43adaa53f93fc902a84c96f52fe1", size = 189550, upload-time = "2025-04-15T17:44:37.092Z" }, + { url = "https://files.pythonhosted.org/packages/b0/e6/6000d0094e8a5e32ad62591c8609e269febb6e4db83a1c75ff8868b42731/contourpy-1.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:78e9253c3de756b3f6a5174d024c4835acd59eb3f8e2ca13e775dbffe1558f69", size = 238214, upload-time = "2025-04-15T17:44:40.827Z" }, + { url = "https://files.pythonhosted.org/packages/33/05/b26e3c6ecc05f349ee0013f0bb850a761016d89cec528a98193a48c34033/contourpy-1.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fd93cc7f3139b6dd7aab2f26a90dde0aa9fc264dbf70f6740d498a70b860b82c", size = 265681, upload-time = "2025-04-15T17:44:59.314Z" }, + { url = "https://files.pythonhosted.org/packages/2b/25/ac07d6ad12affa7d1ffed11b77417d0a6308170f44ff20fa1d5aa6333f03/contourpy-1.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:107ba8a6a7eec58bb475329e6d3b95deba9440667c4d62b9b6063942b61d7f16", size = 315101, upload-time = "2025-04-15T17:45:04.165Z" }, + { url = "https://files.pythonhosted.org/packages/8f/4d/5bb3192bbe9d3f27e3061a6a8e7733c9120e203cb8515767d30973f71030/contourpy-1.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:ded1706ed0c1049224531b81128efbd5084598f18d8a2d9efae833edbd2b40ad", size = 220599, upload-time = "2025-04-15T17:45:08.456Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c0/91f1215d0d9f9f343e4773ba6c9b89e8c0cc7a64a6263f21139da639d848/contourpy-1.3.2-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5f5964cdad279256c084b69c3f412b7801e15356b16efa9d78aa974041903da0", size = 266807, upload-time = "2025-04-15T17:45:15.535Z" }, + { url = "https://files.pythonhosted.org/packages/d4/79/6be7e90c955c0487e7712660d6cead01fa17bff98e0ea275737cc2bc8e71/contourpy-1.3.2-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b65a95d642d4efa8f64ba12558fcb83407e58a2dfba9d796d77b63ccfcaff5", size = 318729, upload-time = "2025-04-15T17:45:20.166Z" }, + { url = "https://files.pythonhosted.org/packages/87/68/7f46fb537958e87427d98a4074bcde4b67a70b04900cfc5ce29bc2f556c1/contourpy-1.3.2-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:8c5acb8dddb0752bf252e01a3035b21443158910ac16a3b0d20e7fed7d534ce5", size = 221791, upload-time = "2025-04-15T17:45:24.794Z" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/91/2e/c4390a31919d8a78b90e8ecf87cd4b4c4f05a5b48d05ec17db8e5404c6f4/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1", size = 288773, upload-time = "2025-07-26T12:01:02.277Z" }, + { url = "https://files.pythonhosted.org/packages/0d/44/c4b0b6095fef4dc9c420e041799591e3b63e9619e3044f7f4f6c21c0ab24/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381", size = 270149, upload-time = "2025-07-26T12:01:04.072Z" }, + { url = "https://files.pythonhosted.org/packages/30/2e/dd4ced42fefac8470661d7cb7e264808425e6c5d56d175291e93890cce09/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7", size = 329222, upload-time = "2025-07-26T12:01:05.688Z" }, + { url = "https://files.pythonhosted.org/packages/f2/74/cc6ec2548e3d276c71389ea4802a774b7aa3558223b7bade3f25787fafc2/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1", size = 377234, upload-time = "2025-07-26T12:01:07.054Z" }, + { url = "https://files.pythonhosted.org/packages/03/b3/64ef723029f917410f75c09da54254c5f9ea90ef89b143ccadb09df14c15/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a", size = 380555, upload-time = "2025-07-26T12:01:08.801Z" }, + { url = "https://files.pythonhosted.org/packages/5f/4b/6157f24ca425b89fe2eb7e7be642375711ab671135be21e6faa100f7448c/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db", size = 355238, upload-time = "2025-07-26T12:01:10.319Z" }, + { url = "https://files.pythonhosted.org/packages/98/56/f914f0dd678480708a04cfd2206e7c382533249bc5001eb9f58aa693e200/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620", size = 1326218, upload-time = "2025-07-26T12:01:12.659Z" }, + { url = "https://files.pythonhosted.org/packages/fb/d7/4a972334a0c971acd5172389671113ae82aa7527073980c38d5868ff1161/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f", size = 1392867, upload-time = "2025-07-26T12:01:15.533Z" }, + { url = "https://files.pythonhosted.org/packages/75/3e/f2cc6cd56dc8cff46b1a56232eabc6feea52720083ea71ab15523daab796/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff", size = 183677, upload-time = "2025-07-26T12:01:17.088Z" }, + { url = "https://files.pythonhosted.org/packages/98/4b/9bd370b004b5c9d8045c6c33cf65bae018b27aca550a3f657cdc99acdbd8/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42", size = 225234, upload-time = "2025-07-26T12:01:18.256Z" }, + { url = "https://files.pythonhosted.org/packages/d9/b6/71771e02c2e004450c12b1120a5f488cad2e4d5b590b1af8bad060360fe4/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470", size = 193123, upload-time = "2025-07-26T12:01:19.848Z" }, + { url = "https://files.pythonhosted.org/packages/be/45/adfee365d9ea3d853550b2e735f9d66366701c65db7855cd07621732ccfc/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb", size = 293419, upload-time = "2025-07-26T12:01:21.16Z" }, + { url = "https://files.pythonhosted.org/packages/53/3e/405b59cfa13021a56bba395a6b3aca8cec012b45bf177b0eaf7a202cde2c/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6", size = 273979, upload-time = "2025-07-26T12:01:22.448Z" }, + { url = "https://files.pythonhosted.org/packages/d4/1c/a12359b9b2ca3a845e8f7f9ac08bdf776114eb931392fcad91743e2ea17b/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7", size = 332653, upload-time = "2025-07-26T12:01:24.155Z" }, + { url = "https://files.pythonhosted.org/packages/63/12/897aeebfb475b7748ea67b61e045accdfcf0d971f8a588b67108ed7f5512/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8", size = 379536, upload-time = "2025-07-26T12:01:25.91Z" }, + { url = "https://files.pythonhosted.org/packages/43/8a/a8c584b82deb248930ce069e71576fc09bd7174bbd35183b7943fb1064fd/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea", size = 384397, upload-time = "2025-07-26T12:01:27.152Z" }, + { url = "https://files.pythonhosted.org/packages/cc/8f/ec6289987824b29529d0dfda0d74a07cec60e54b9c92f3c9da4c0ac732de/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1", size = 362601, upload-time = "2025-07-26T12:01:28.808Z" }, + { url = "https://files.pythonhosted.org/packages/05/0a/a3fe3be3ee2dceb3e615ebb4df97ae6f3828aa915d3e10549ce016302bd1/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7", size = 1331288, upload-time = "2025-07-26T12:01:31.198Z" }, + { url = "https://files.pythonhosted.org/packages/33/1d/acad9bd4e97f13f3e2b18a3977fe1b4a37ecf3d38d815333980c6c72e963/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411", size = 1403386, upload-time = "2025-07-26T12:01:33.947Z" }, + { url = "https://files.pythonhosted.org/packages/cf/8f/5847f44a7fddf859704217a99a23a4f6417b10e5ab1256a179264561540e/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69", size = 185018, upload-time = "2025-07-26T12:01:35.64Z" }, + { url = "https://files.pythonhosted.org/packages/19/e8/6026ed58a64563186a9ee3f29f41261fd1828f527dd93d33b60feca63352/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b", size = 226567, upload-time = "2025-07-26T12:01:36.804Z" }, + { url = "https://files.pythonhosted.org/packages/d1/e2/f05240d2c39a1ed228d8328a78b6f44cd695f7ef47beb3e684cf93604f86/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc", size = 193655, upload-time = "2025-07-26T12:01:37.999Z" }, + { url = "https://files.pythonhosted.org/packages/68/35/0167aad910bbdb9599272bd96d01a9ec6852f36b9455cf2ca67bd4cc2d23/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5", size = 293257, upload-time = "2025-07-26T12:01:39.367Z" }, + { url = "https://files.pythonhosted.org/packages/96/e4/7adcd9c8362745b2210728f209bfbcf7d91ba868a2c5f40d8b58f54c509b/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1", size = 274034, upload-time = "2025-07-26T12:01:40.645Z" }, + { url = "https://files.pythonhosted.org/packages/73/23/90e31ceeed1de63058a02cb04b12f2de4b40e3bef5e082a7c18d9c8ae281/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286", size = 334672, upload-time = "2025-07-26T12:01:41.942Z" }, + { url = "https://files.pythonhosted.org/packages/ed/93/b43d8acbe67392e659e1d984700e79eb67e2acb2bd7f62012b583a7f1b55/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5", size = 381234, upload-time = "2025-07-26T12:01:43.499Z" }, + { url = "https://files.pythonhosted.org/packages/46/3b/bec82a3ea06f66711520f75a40c8fc0b113b2a75edb36aa633eb11c4f50f/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67", size = 385169, upload-time = "2025-07-26T12:01:45.219Z" }, + { url = "https://files.pythonhosted.org/packages/4b/32/e0f13a1c5b0f8572d0ec6ae2f6c677b7991fafd95da523159c19eff0696a/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9", size = 362859, upload-time = "2025-07-26T12:01:46.519Z" }, + { url = "https://files.pythonhosted.org/packages/33/71/e2a7945b7de4e58af42d708a219f3b2f4cff7386e6b6ab0a0fa0033c49a9/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659", size = 1332062, upload-time = "2025-07-26T12:01:48.964Z" }, + { url = "https://files.pythonhosted.org/packages/12/fc/4e87ac754220ccc0e807284f88e943d6d43b43843614f0a8afa469801db0/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7", size = 1403932, upload-time = "2025-07-26T12:01:51.979Z" }, + { url = "https://files.pythonhosted.org/packages/a6/2e/adc197a37443f934594112222ac1aa7dc9a98faf9c3842884df9a9d8751d/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d", size = 185024, upload-time = "2025-07-26T12:01:53.245Z" }, + { url = "https://files.pythonhosted.org/packages/18/0b/0098c214843213759692cc638fce7de5c289200a830e5035d1791d7a2338/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263", size = 226578, upload-time = "2025-07-26T12:01:54.422Z" }, + { url = "https://files.pythonhosted.org/packages/8a/9a/2f6024a0c5995243cd63afdeb3651c984f0d2bc727fd98066d40e141ad73/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9", size = 193524, upload-time = "2025-07-26T12:01:55.73Z" }, + { url = "https://files.pythonhosted.org/packages/c0/b3/f8a1a86bd3298513f500e5b1f5fd92b69896449f6cab6a146a5d52715479/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d", size = 306730, upload-time = "2025-07-26T12:01:57.051Z" }, + { url = "https://files.pythonhosted.org/packages/3f/11/4780db94ae62fc0c2053909b65dc3246bd7cecfc4f8a20d957ad43aa4ad8/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216", size = 287897, upload-time = "2025-07-26T12:01:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/15/e59f5f3ffdd6f3d4daa3e47114c53daabcb18574a26c21f03dc9e4e42ff0/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae", size = 326751, upload-time = "2025-07-26T12:02:00.343Z" }, + { url = "https://files.pythonhosted.org/packages/0f/81/03b45cfad088e4770b1dcf72ea78d3802d04200009fb364d18a493857210/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20", size = 375486, upload-time = "2025-07-26T12:02:02.128Z" }, + { url = "https://files.pythonhosted.org/packages/0c/ba/49923366492ffbdd4486e970d421b289a670ae8cf539c1ea9a09822b371a/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99", size = 388106, upload-time = "2025-07-26T12:02:03.615Z" }, + { url = "https://files.pythonhosted.org/packages/9f/52/5b00ea89525f8f143651f9f03a0df371d3cbd2fccd21ca9b768c7a6500c2/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b", size = 352548, upload-time = "2025-07-26T12:02:05.165Z" }, + { url = "https://files.pythonhosted.org/packages/32/1d/a209ec1a3a3452d490f6b14dd92e72280c99ae3d1e73da74f8277d4ee08f/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a", size = 1322297, upload-time = "2025-07-26T12:02:07.379Z" }, + { url = "https://files.pythonhosted.org/packages/bc/9e/46f0e8ebdd884ca0e8877e46a3f4e633f6c9c8c4f3f6e72be3fe075994aa/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e", size = 1391023, upload-time = "2025-07-26T12:02:10.171Z" }, + { url = "https://files.pythonhosted.org/packages/b9/70/f308384a3ae9cd2209e0849f33c913f658d3326900d0ff5d378d6a1422d2/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3", size = 196157, upload-time = "2025-07-26T12:02:11.488Z" }, + { url = "https://files.pythonhosted.org/packages/b2/dd/880f890a6663b84d9e34a6f88cded89d78f0091e0045a284427cb6b18521/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8", size = 240570, upload-time = "2025-07-26T12:02:12.754Z" }, + { url = "https://files.pythonhosted.org/packages/80/99/2adc7d8ffead633234817ef8e9a87115c8a11927a94478f6bb3d3f4d4f7d/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301", size = 199713, upload-time = "2025-07-26T12:02:14.4Z" }, + { url = "https://files.pythonhosted.org/packages/72/8b/4546f3ab60f78c514ffb7d01a0bd743f90de36f0019d1be84d0a708a580a/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a", size = 292189, upload-time = "2025-07-26T12:02:16.095Z" }, + { url = "https://files.pythonhosted.org/packages/fd/e1/3542a9cb596cadd76fcef413f19c79216e002623158befe6daa03dbfa88c/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77", size = 273251, upload-time = "2025-07-26T12:02:17.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/71/f93e1e9471d189f79d0ce2497007731c1e6bf9ef6d1d61b911430c3db4e5/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5", size = 335810, upload-time = "2025-07-26T12:02:18.9Z" }, + { url = "https://files.pythonhosted.org/packages/91/f9/e35f4c1c93f9275d4e38681a80506b5510e9327350c51f8d4a5a724d178c/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4", size = 382871, upload-time = "2025-07-26T12:02:20.418Z" }, + { url = "https://files.pythonhosted.org/packages/b5/71/47b512f936f66a0a900d81c396a7e60d73419868fba959c61efed7a8ab46/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36", size = 386264, upload-time = "2025-07-26T12:02:21.916Z" }, + { url = "https://files.pythonhosted.org/packages/04/5f/9ff93450ba96b09c7c2b3f81c94de31c89f92292f1380261bd7195bea4ea/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3", size = 363819, upload-time = "2025-07-26T12:02:23.759Z" }, + { url = "https://files.pythonhosted.org/packages/3e/a6/0b185d4cc480ee494945cde102cb0149ae830b5fa17bf855b95f2e70ad13/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b", size = 1333650, upload-time = "2025-07-26T12:02:26.181Z" }, + { url = "https://files.pythonhosted.org/packages/43/d7/afdc95580ca56f30fbcd3060250f66cedbde69b4547028863abd8aa3b47e/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36", size = 1404833, upload-time = "2025-07-26T12:02:28.782Z" }, + { url = "https://files.pythonhosted.org/packages/e2/e2/366af18a6d386f41132a48f033cbd2102e9b0cf6345d35ff0826cd984566/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d", size = 189692, upload-time = "2025-07-26T12:02:30.128Z" }, + { url = "https://files.pythonhosted.org/packages/7d/c2/57f54b03d0f22d4044b8afb9ca0e184f8b1afd57b4f735c2fa70883dc601/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd", size = 232424, upload-time = "2025-07-26T12:02:31.395Z" }, + { url = "https://files.pythonhosted.org/packages/18/79/a9416650df9b525737ab521aa181ccc42d56016d2123ddcb7b58e926a42c/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339", size = 198300, upload-time = "2025-07-26T12:02:32.956Z" }, + { url = "https://files.pythonhosted.org/packages/1f/42/38c159a7d0f2b7b9c04c64ab317042bb6952b713ba875c1681529a2932fe/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772", size = 306769, upload-time = "2025-07-26T12:02:34.2Z" }, + { url = "https://files.pythonhosted.org/packages/c3/6c/26a8205f24bca10974e77460de68d3d7c63e282e23782f1239f226fcae6f/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77", size = 287892, upload-time = "2025-07-26T12:02:35.807Z" }, + { url = "https://files.pythonhosted.org/packages/66/06/8a475c8ab718ebfd7925661747dbb3c3ee9c82ac834ccb3570be49d129f4/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13", size = 326748, upload-time = "2025-07-26T12:02:37.193Z" }, + { url = "https://files.pythonhosted.org/packages/b4/a3/c5ca9f010a44c223f098fccd8b158bb1cb287378a31ac141f04730dc49be/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe", size = 375554, upload-time = "2025-07-26T12:02:38.894Z" }, + { url = "https://files.pythonhosted.org/packages/80/5b/68bd33ae63fac658a4145088c1e894405e07584a316738710b636c6d0333/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f", size = 388118, upload-time = "2025-07-26T12:02:40.642Z" }, + { url = "https://files.pythonhosted.org/packages/40/52/4c285a6435940ae25d7410a6c36bda5145839bc3f0beb20c707cda18b9d2/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0", size = 352555, upload-time = "2025-07-26T12:02:42.25Z" }, + { url = "https://files.pythonhosted.org/packages/24/ee/3e81e1dd174f5c7fefe50e85d0892de05ca4e26ef1c9a59c2a57e43b865a/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4", size = 1322295, upload-time = "2025-07-26T12:02:44.668Z" }, + { url = "https://files.pythonhosted.org/packages/3c/b2/6d913d4d04e14379de429057cd169e5e00f6c2af3bb13e1710bcbdb5da12/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f", size = 1391027, upload-time = "2025-07-26T12:02:47.09Z" }, + { url = "https://files.pythonhosted.org/packages/93/8a/68a4ec5c55a2971213d29a9374913f7e9f18581945a7a31d1a39b5d2dfe5/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae", size = 202428, upload-time = "2025-07-26T12:02:48.691Z" }, + { url = "https://files.pythonhosted.org/packages/fa/96/fd9f641ffedc4fa3ace923af73b9d07e869496c9cc7a459103e6e978992f/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc", size = 250331, upload-time = "2025-07-26T12:02:50.137Z" }, + { url = "https://files.pythonhosted.org/packages/ae/8c/469afb6465b853afff216f9528ffda78a915ff880ed58813ba4faf4ba0b6/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b", size = 203831, upload-time = "2025-07-26T12:02:51.449Z" }, + { url = "https://files.pythonhosted.org/packages/a5/29/8dcfe16f0107943fa92388c23f6e05cff0ba58058c4c95b00280d4c75a14/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497", size = 278809, upload-time = "2025-07-26T12:02:52.74Z" }, + { url = "https://files.pythonhosted.org/packages/85/a9/8b37ef4f7dafeb335daee3c8254645ef5725be4d9c6aa70b50ec46ef2f7e/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8", size = 261593, upload-time = "2025-07-26T12:02:54.037Z" }, + { url = "https://files.pythonhosted.org/packages/0a/59/ebfb8c677c75605cc27f7122c90313fd2f375ff3c8d19a1694bda74aaa63/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e", size = 302202, upload-time = "2025-07-26T12:02:55.947Z" }, + { url = "https://files.pythonhosted.org/packages/3c/37/21972a15834d90bfbfb009b9d004779bd5a07a0ec0234e5ba8f64d5736f4/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989", size = 329207, upload-time = "2025-07-26T12:02:57.468Z" }, + { url = "https://files.pythonhosted.org/packages/0c/58/bd257695f39d05594ca4ad60df5bcb7e32247f9951fd09a9b8edb82d1daa/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77", size = 225315, upload-time = "2025-07-26T12:02:58.801Z" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/a9/95/a3dbbb5028f35eafb79008e7522a75244477d2838f38cbb722248dabc2a8/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c", size = 7615, upload-time = "2023-10-07T05:32:18.335Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/05/c19819d5e3d95294a6f5947fb9b9629efb316b96de511b418c53d245aae6/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30", size = 8321, upload-time = "2023-10-07T05:32:16.783Z" }, +] + +[[package]] +name = "cython" +version = "3.2.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/91/85/7574c9cd44b69a27210444b6650f6477f56c75fee1b70d7672d3e4166167/cython-3.2.4.tar.gz", hash = "sha256:84226ecd313b233da27dc2eb3601b4f222b8209c3a7216d8733b031da1dc64e6", size = 3280291, upload-time = "2026-01-04T14:14:14.473Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a1/10/720e0fb84eab4c927c4dd6b61eb7993f7732dd83d29ba6d73083874eade9/cython-3.2.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02cb0cc0f23b9874ad262d7d2b9560aed9c7e2df07b49b920bda6f2cc9cb505e", size = 2960836, upload-time = "2026-01-04T14:14:51.103Z" }, + { url = "https://files.pythonhosted.org/packages/7d/3d/b26f29092c71c36e0462752885bdfb18c23c176af4de953fdae2772a8941/cython-3.2.4-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f136f379a4a54246facd0eb6f1ee15c3837cb314ce87b677582ec014db4c6845", size = 3370134, upload-time = "2026-01-04T14:14:53.627Z" }, + { url = "https://files.pythonhosted.org/packages/56/9e/539fb0d09e4f5251b5b14f8daf77e71fee021527f1013791038234618b6b/cython-3.2.4-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:35ab0632186057406ec729374c737c37051d2eacad9d515d94e5a3b3e58a9b02", size = 3537552, upload-time = "2026-01-04T14:14:56.852Z" }, + { url = "https://files.pythonhosted.org/packages/10/c6/82d19a451c050d1be0f05b1a3302267463d391db548f013ee88b5348a8e9/cython-3.2.4-cp310-cp310-win_amd64.whl", hash = "sha256:ca2399dc75796b785f74fb85c938254fa10c80272004d573c455f9123eceed86", size = 2766191, upload-time = "2026-01-04T14:14:58.709Z" }, + { url = "https://files.pythonhosted.org/packages/85/cc/8f06145ec3efa121c8b1b67f06a640386ddacd77ee3e574da582a21b14ee/cython-3.2.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ff9af2134c05e3734064808db95b4dd7341a39af06e8945d05ea358e1741aaed", size = 2953769, upload-time = "2026-01-04T14:15:00.361Z" }, + { url = "https://files.pythonhosted.org/packages/55/b0/706cf830eddd831666208af1b3058c2e0758ae157590909c1f634b53bed9/cython-3.2.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67922c9de058a0bfb72d2e75222c52d09395614108c68a76d9800f150296ddb3", size = 3243841, upload-time = "2026-01-04T14:15:02.066Z" }, + { url = "https://files.pythonhosted.org/packages/ac/25/58893afd4ef45f79e3d4db82742fa4ff874b936d67a83c92939053920ccd/cython-3.2.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b362819d155fff1482575e804e43e3a8825332d32baa15245f4642022664a3f4", size = 3378083, upload-time = "2026-01-04T14:15:04.248Z" }, + { url = "https://files.pythonhosted.org/packages/32/e4/424a004d7c0d8a4050c81846ebbd22272ececfa9a498cb340aa44fccbec2/cython-3.2.4-cp311-cp311-win_amd64.whl", hash = "sha256:1a64a112a34ec719b47c01395647e54fb4cf088a511613f9a3a5196694e8e382", size = 2769990, upload-time = "2026-01-04T14:15:06.53Z" }, + { url = "https://files.pythonhosted.org/packages/91/4d/1eb0c7c196a136b1926f4d7f0492a96c6fabd604d77e6cd43b56a3a16d83/cython-3.2.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:64d7f71be3dd6d6d4a4c575bb3a4674ea06d1e1e5e4cd1b9882a2bc40ed3c4c9", size = 2970064, upload-time = "2026-01-04T14:15:08.567Z" }, + { url = "https://files.pythonhosted.org/packages/03/1c/46e34b08bea19a1cdd1e938a4c123e6299241074642db9d81983cef95e9f/cython-3.2.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:869487ea41d004f8b92171f42271fbfadb1ec03bede3158705d16cd570d6b891", size = 3226757, upload-time = "2026-01-04T14:15:10.812Z" }, + { url = "https://files.pythonhosted.org/packages/12/33/3298a44d201c45bcf0d769659725ae70e9c6c42adf8032f6d89c8241098d/cython-3.2.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:55b6c44cd30821f0b25220ceba6fe636ede48981d2a41b9bbfe3c7902ce44ea7", size = 3388969, upload-time = "2026-01-04T14:15:12.45Z" }, + { url = "https://files.pythonhosted.org/packages/bb/f3/4275cd3ea0a4cf4606f9b92e7f8766478192010b95a7f516d1b7cf22cb10/cython-3.2.4-cp312-cp312-win_amd64.whl", hash = "sha256:767b143704bdd08a563153448955935844e53b852e54afdc552b43902ed1e235", size = 2756457, upload-time = "2026-01-04T14:15:14.67Z" }, + { url = "https://files.pythonhosted.org/packages/18/b5/1cfca43b7d20a0fdb1eac67313d6bb6b18d18897f82dd0f17436bdd2ba7f/cython-3.2.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:28e8075087a59756f2d059273184b8b639fe0f16cf17470bd91c39921bc154e0", size = 2960506, upload-time = "2026-01-04T14:15:16.733Z" }, + { url = "https://files.pythonhosted.org/packages/71/bb/8f28c39c342621047fea349a82fac712a5e2b37546d2f737bbde48d5143d/cython-3.2.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:03893c88299a2c868bb741ba6513357acd104e7c42265809fd58dce1456a36fc", size = 3213148, upload-time = "2026-01-04T14:15:18.804Z" }, + { url = "https://files.pythonhosted.org/packages/7a/d2/16fa02f129ed2b627e88d9d9ebd5ade3eeb66392ae5ba85b259d2d52b047/cython-3.2.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f81eda419b5ada7b197bbc3c5f4494090e3884521ffd75a3876c93fbf66c9ca8", size = 3375764, upload-time = "2026-01-04T14:15:20.817Z" }, + { url = "https://files.pythonhosted.org/packages/91/3f/deb8f023a5c10c0649eb81332a58c180fad27c7533bb4aae138b5bc34d92/cython-3.2.4-cp313-cp313-win_amd64.whl", hash = "sha256:83266c356c13c68ffe658b4905279c993d8a5337bb0160fa90c8a3e297ea9a2e", size = 2754238, upload-time = "2026-01-04T14:15:23.001Z" }, + { url = "https://files.pythonhosted.org/packages/ee/d7/3bda3efce0c5c6ce79cc21285dbe6f60369c20364e112f5a506ee8a1b067/cython-3.2.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:d4b4fd5332ab093131fa6172e8362f16adef3eac3179fd24bbdc392531cb82fa", size = 2971496, upload-time = "2026-01-04T14:15:25.038Z" }, + { url = "https://files.pythonhosted.org/packages/89/ed/1021ffc80b9c4720b7ba869aea8422c82c84245ef117ebe47a556bdc00c3/cython-3.2.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e3b5ac54e95f034bc7fb07313996d27cbf71abc17b229b186c1540942d2dc28e", size = 3256146, upload-time = "2026-01-04T14:15:26.741Z" }, + { url = "https://files.pythonhosted.org/packages/0c/51/ca221ec7e94b3c5dc4138dcdcbd41178df1729c1e88c5dfb25f9d30ba3da/cython-3.2.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:90f43be4eaa6afd58ce20d970bb1657a3627c44e1760630b82aa256ba74b4acb", size = 3383458, upload-time = "2026-01-04T14:15:28.425Z" }, + { url = "https://files.pythonhosted.org/packages/79/2e/1388fc0243240cd54994bb74f26aaaf3b2e22f89d3a2cf8da06d75d46ca2/cython-3.2.4-cp314-cp314-win_amd64.whl", hash = "sha256:983f9d2bb8a896e16fa68f2b37866ded35fa980195eefe62f764ddc5f9f5ef8e", size = 2791241, upload-time = "2026-01-04T14:15:30.448Z" }, + { url = "https://files.pythonhosted.org/packages/0a/8b/fd393f0923c82be4ec0db712fffb2ff0a7a131707b842c99bf24b549274d/cython-3.2.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:36bf3f5eb56d5281aafabecbaa6ed288bc11db87547bba4e1e52943ae6961ccf", size = 2875622, upload-time = "2026-01-04T14:15:39.749Z" }, + { url = "https://files.pythonhosted.org/packages/73/48/48530d9b9d64ec11dbe0dd3178a5fe1e0b27977c1054ecffb82be81e9b6a/cython-3.2.4-cp39-abi3-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:6d5267f22b6451eb1e2e1b88f6f78a2c9c8733a6ddefd4520d3968d26b824581", size = 3210669, upload-time = "2026-01-04T14:15:41.911Z" }, + { url = "https://files.pythonhosted.org/packages/5e/91/4865fbfef1f6bb4f21d79c46104a53d1a3fa4348286237e15eafb26e0828/cython-3.2.4-cp39-abi3-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3b6e58f73a69230218d5381817850ce6d0da5bb7e87eb7d528c7027cbba40b06", size = 2856835, upload-time = "2026-01-04T14:15:43.815Z" }, + { url = "https://files.pythonhosted.org/packages/fa/39/60317957dbef179572398253f29d28f75f94ab82d6d39ea3237fb6c89268/cython-3.2.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:e71efb20048358a6b8ec604a0532961c50c067b5e63e345e2e359fff72feaee8", size = 2994408, upload-time = "2026-01-04T14:15:45.422Z" }, + { url = "https://files.pythonhosted.org/packages/8d/30/7c24d9292650db4abebce98abc9b49c820d40fa7c87921c0a84c32f4efe7/cython-3.2.4-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:28b1e363b024c4b8dcf52ff68125e635cb9cb4b0ba997d628f25e32543a71103", size = 2891478, upload-time = "2026-01-04T14:15:47.394Z" }, + { url = "https://files.pythonhosted.org/packages/86/70/03dc3c962cde9da37a93cca8360e576f904d5f9beecfc9d70b1f820d2e5f/cython-3.2.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:31a90b4a2c47bb6d56baeb926948348ec968e932c1ae2c53239164e3e8880ccf", size = 3225663, upload-time = "2026-01-04T14:15:49.446Z" }, + { url = "https://files.pythonhosted.org/packages/b1/97/10b50c38313c37b1300325e2e53f48ea9a2c078a85c0c9572057135e31d5/cython-3.2.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:e65e4773021f8dc8532010b4fbebe782c77f9a0817e93886e518c93bd6a44e9d", size = 3115628, upload-time = "2026-01-04T14:15:51.323Z" }, + { url = "https://files.pythonhosted.org/packages/8f/b1/d6a353c9b147848122a0db370863601fdf56de2d983b5c4a6a11e6ee3cd7/cython-3.2.4-cp39-abi3-win32.whl", hash = "sha256:2b1f12c0e4798293d2754e73cd6f35fa5bbdf072bdc14bc6fc442c059ef2d290", size = 2437463, upload-time = "2026-01-04T14:15:53.787Z" }, + { url = "https://files.pythonhosted.org/packages/2d/d8/319a1263b9c33b71343adfd407e5daffd453daef47ebc7b642820a8b68ed/cython-3.2.4-cp39-abi3-win_arm64.whl", hash = "sha256:3b8e62049afef9da931d55de82d8f46c9a147313b69d5ff6af6e9121d545ce7a", size = 2442754, upload-time = "2026-01-04T14:15:55.382Z" }, + { url = "https://files.pythonhosted.org/packages/ff/fa/d3c15189f7c52aaefbaea76fb012119b04b9013f4bf446cb4eb4c26c4e6b/cython-3.2.4-py3-none-any.whl", hash = "sha256:732fc93bc33ae4b14f6afaca663b916c2fdd5dcbfad7114e17fb2434eeaea45c", size = 1257078, upload-time = "2026-01-04T14:14:12.373Z" }, +] + +[[package]] +name = "debugpy" +version = "1.8.20" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e0/b7/cd8080344452e4874aae67c40d8940e2b4d47b01601a8fd9f44786c757c7/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33", size = 1645207, upload-time = "2026-01-29T23:03:28.199Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/71/be/8bd693a0b9d53d48c8978fa5d889e06f3b5b03e45fd1ea1e78267b4887cb/debugpy-1.8.20-cp310-cp310-macosx_15_0_x86_64.whl", hash = "sha256:157e96ffb7f80b3ad36d808646198c90acb46fdcfd8bb1999838f0b6f2b59c64", size = 2099192, upload-time = "2026-01-29T23:03:29.707Z" }, + { url = "https://files.pythonhosted.org/packages/77/1b/85326d07432086a06361d493d2743edd0c4fc2ef62162be7f8618441ac37/debugpy-1.8.20-cp310-cp310-manylinux_2_34_x86_64.whl", hash = "sha256:c1178ae571aff42e61801a38b007af504ec8e05fde1c5c12e5a7efef21009642", size = 3088568, upload-time = "2026-01-29T23:03:31.467Z" }, + { url = "https://files.pythonhosted.org/packages/e8/60/3e08462ee3eccd10998853eb35947c416e446bfe2bc37dbb886b9044586c/debugpy-1.8.20-cp310-cp310-win32.whl", hash = "sha256:c29dd9d656c0fbd77906a6e6a82ae4881514aa3294b94c903ff99303e789b4a2", size = 5284399, upload-time = "2026-01-29T23:03:33.678Z" }, + { url = "https://files.pythonhosted.org/packages/72/43/09d49106e770fe558ced5e80df2e3c2ebee10e576eda155dcc5670473663/debugpy-1.8.20-cp310-cp310-win_amd64.whl", hash = "sha256:3ca85463f63b5dd0aa7aaa933d97cbc47c174896dcae8431695872969f981893", size = 5316388, upload-time = "2026-01-29T23:03:35.095Z" }, + { url = "https://files.pythonhosted.org/packages/51/56/c3baf5cbe4dd77427fd9aef99fcdade259ad128feeb8a786c246adb838e5/debugpy-1.8.20-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:eada6042ad88fa1571b74bd5402ee8b86eded7a8f7b827849761700aff171f1b", size = 2208318, upload-time = "2026-01-29T23:03:36.481Z" }, + { url = "https://files.pythonhosted.org/packages/9a/7d/4fa79a57a8e69fe0d9763e98d1110320f9ecd7f1f362572e3aafd7417c9d/debugpy-1.8.20-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:7de0b7dfeedc504421032afba845ae2a7bcc32ddfb07dae2c3ca5442f821c344", size = 3171493, upload-time = "2026-01-29T23:03:37.775Z" }, + { url = "https://files.pythonhosted.org/packages/7d/f2/1e8f8affe51e12a26f3a8a8a4277d6e60aa89d0a66512f63b1e799d424a4/debugpy-1.8.20-cp311-cp311-win32.whl", hash = "sha256:773e839380cf459caf73cc533ea45ec2737a5cc184cf1b3b796cd4fd98504fec", size = 5209240, upload-time = "2026-01-29T23:03:39.109Z" }, + { url = "https://files.pythonhosted.org/packages/d5/92/1cb532e88560cbee973396254b21bece8c5d7c2ece958a67afa08c9f10dc/debugpy-1.8.20-cp311-cp311-win_amd64.whl", hash = "sha256:1f7650546e0eded1902d0f6af28f787fa1f1dbdbc97ddabaf1cd963a405930cb", size = 5233481, upload-time = "2026-01-29T23:03:40.659Z" }, + { url = "https://files.pythonhosted.org/packages/14/57/7f34f4736bfb6e00f2e4c96351b07805d83c9a7b33d28580ae01374430f7/debugpy-1.8.20-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:4ae3135e2089905a916909ef31922b2d733d756f66d87345b3e5e52b7a55f13d", size = 2550686, upload-time = "2026-01-29T23:03:42.023Z" }, + { url = "https://files.pythonhosted.org/packages/ab/78/b193a3975ca34458f6f0e24aaf5c3e3da72f5401f6054c0dfd004b41726f/debugpy-1.8.20-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:88f47850a4284b88bd2bfee1f26132147d5d504e4e86c22485dfa44b97e19b4b", size = 4310588, upload-time = "2026-01-29T23:03:43.314Z" }, + { url = "https://files.pythonhosted.org/packages/c1/55/f14deb95eaf4f30f07ef4b90a8590fc05d9e04df85ee379712f6fb6736d7/debugpy-1.8.20-cp312-cp312-win32.whl", hash = "sha256:4057ac68f892064e5f98209ab582abfee3b543fb55d2e87610ddc133a954d390", size = 5331372, upload-time = "2026-01-29T23:03:45.526Z" }, + { url = "https://files.pythonhosted.org/packages/a1/39/2bef246368bd42f9bd7cba99844542b74b84dacbdbea0833e610f384fee8/debugpy-1.8.20-cp312-cp312-win_amd64.whl", hash = "sha256:a1a8f851e7cf171330679ef6997e9c579ef6dd33c9098458bd9986a0f4ca52e3", size = 5372835, upload-time = "2026-01-29T23:03:47.245Z" }, + { url = "https://files.pythonhosted.org/packages/15/e2/fc500524cc6f104a9d049abc85a0a8b3f0d14c0a39b9c140511c61e5b40b/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a", size = 2539560, upload-time = "2026-01-29T23:03:48.738Z" }, + { url = "https://files.pythonhosted.org/packages/90/83/fb33dcea789ed6018f8da20c5a9bc9d82adc65c0c990faed43f7c955da46/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf", size = 4293272, upload-time = "2026-01-29T23:03:50.169Z" }, + { url = "https://files.pythonhosted.org/packages/a6/25/b1e4a01bfb824d79a6af24b99ef291e24189080c93576dfd9b1a2815cd0f/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393", size = 5331208, upload-time = "2026-01-29T23:03:51.547Z" }, + { url = "https://files.pythonhosted.org/packages/13/f7/a0b368ce54ffff9e9028c098bd2d28cfc5b54f9f6c186929083d4c60ba58/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7", size = 5372930, upload-time = "2026-01-29T23:03:53.585Z" }, + { url = "https://files.pythonhosted.org/packages/33/2e/f6cb9a8a13f5058f0a20fe09711a7b726232cd5a78c6a7c05b2ec726cff9/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173", size = 2538066, upload-time = "2026-01-29T23:03:54.999Z" }, + { url = "https://files.pythonhosted.org/packages/c5/56/6ddca50b53624e1ca3ce1d1e49ff22db46c47ea5fb4c0cc5c9b90a616364/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad", size = 4269425, upload-time = "2026-01-29T23:03:56.518Z" }, + { url = "https://files.pythonhosted.org/packages/c5/d9/d64199c14a0d4c476df46c82470a3ce45c8d183a6796cfb5e66533b3663c/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f", size = 5331407, upload-time = "2026-01-29T23:03:58.481Z" }, + { url = "https://files.pythonhosted.org/packages/e0/d9/1f07395b54413432624d61524dfd98c1a7c7827d2abfdb8829ac92638205/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be", size = 5372521, upload-time = "2026-01-29T23:03:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/e0/c3/7f67dea8ccf8fdcb9c99033bbe3e90b9e7395415843accb81428c441be2d/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7", size = 5337658, upload-time = "2026-01-29T23:04:17.404Z" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/43/fa/6d96a0978d19e17b68d634497769987b16c8f4cd0a7a05048bec693caa6b/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360", size = 56711, upload-time = "2025-02-24T04:41:34.073Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/4e/8c/f3147f5c4b73e7550fe5f9352eaa956ae838d5c51eb58e7a25b9f3e2643b/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a", size = 9190, upload-time = "2025-02-24T04:41:32.565Z" }, +] + +[[package]] +name = "dill" +version = "0.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/81/e1/56027a71e31b02ddc53c7d65b01e68edf64dea2932122fe7746a516f75d5/dill-0.4.1.tar.gz", hash = "sha256:423092df4182177d4d8ba8290c8a5b640c66ab35ec7da59ccfa00f6fa3eea5fa", size = 187315, upload-time = "2026-01-19T02:36:56.85Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/1e/77/dc8c558f7593132cf8fefec57c4f60c83b16941c574ac5f619abb3ae7933/dill-0.4.1-py3-none-any.whl", hash = "sha256:1e1ce33e978ae97fcfcff5638477032b801c46c7c65cf717f95fbc2248f79a9d", size = 120019, upload-time = "2026-01-19T02:36:55.663Z" }, +] + +[[package]] +name = "exceptiongroup" +version = "1.3.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8a/0e/97c33bf5009bdbac74fd2beace167cab3f978feb69cc36f1ef79360d6c4e/exceptiongroup-1.3.1-py3-none-any.whl", hash = "sha256:a7a39a3bd276781e98394987d3a5701d0c4edffb633bb7a5144577f82c773598", size = 16740, upload-time = "2025-11-21T23:01:53.443Z" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cc/28/c14e053b6762b1044f34a13aab6859bbf40456d37d23aa286ac24cfd9a5d/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4", size = 1129488, upload-time = "2025-09-01T09:48:10.866Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c1/ea/53f2148663b321f21b5a606bd5f191517cf40b7072c0497d3c92c4a13b1e/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017", size = 28317, upload-time = "2025-09-01T09:48:08.5Z" }, +] + +[[package]] +name = "farama-notifications" +version = "0.0.4" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2e/2c/8384832b7a6b1fd6ba95bbdcae26e7137bb3eedc955c42fd5cdcc086cfbf/Farama-Notifications-0.0.4.tar.gz", hash = "sha256:13fceff2d14314cf80703c8266462ebf3733c7d165336eee998fc58e545efd18", size = 2131, upload-time = "2023-02-27T18:28:41.047Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/05/2c/ffc08c54c05cdce6fbed2aeebc46348dbe180c6d2c541c7af7ba0aa5f5f8/Farama_Notifications-0.0.4-py3-none-any.whl", hash = "sha256:14de931035a41961f7c056361dc7f980762a143d05791ef5794a751a2caf05ae", size = 2511, upload-time = "2023-02-27T18:28:39.447Z" }, +] + +[[package]] +name = "fonttools" +version = "4.62.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9a/08/7012b00a9a5874311b639c3920270c36ee0c445b69d9989a85e5c92ebcb0/fonttools-4.62.1.tar.gz", hash = "sha256:e54c75fd6041f1122476776880f7c3c3295ffa31962dc6ebe2543c00dca58b5d", size = 3580737, upload-time = "2026-03-13T13:54:25.52Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/ff/532ed43808b469c807e8cb6b21358da3fe6fd51486b3a8c93db0bb5d957f/fonttools-4.62.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ad5cca75776cd453b1b035b530e943334957ae152a36a88a320e779d61fc980c", size = 2873740, upload-time = "2026-03-13T13:52:11.822Z" }, + { url = "https://files.pythonhosted.org/packages/85/e4/2318d2b430562da7227010fb2bb029d2fa54d7b46443ae8942bab224e2a0/fonttools-4.62.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0b3ae47e8636156a9accff64c02c0924cbebad62854c4a6dbdc110cd5b4b341a", size = 2417649, upload-time = "2026-03-13T13:52:14.605Z" }, + { url = "https://files.pythonhosted.org/packages/4c/28/40f15523b5188598018e7956899fed94eb7debec89e2dd70cb4a8df90492/fonttools-4.62.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b9e288b4da2f64fd6180644221749de651703e8d0c16bd4b719533a3a7d6e3", size = 4935213, upload-time = "2026-03-13T13:52:17.399Z" }, + { url = "https://files.pythonhosted.org/packages/42/09/7dbe3d7023f57d9b580cfa832109d521988112fd59dddfda3fddda8218f9/fonttools-4.62.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7bca7a1c1faf235ffe25d4f2e555246b4750220b38de8261d94ebc5ce8a23c23", size = 4892374, upload-time = "2026-03-13T13:52:20.175Z" }, + { url = "https://files.pythonhosted.org/packages/d1/2d/84509a2e32cb925371560ef5431365d8da2183c11d98e5b4b8b4e42426a5/fonttools-4.62.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b4e0fcf265ad26e487c56cb12a42dffe7162de708762db951e1b3f755319507d", size = 4911856, upload-time = "2026-03-13T13:52:22.777Z" }, + { url = "https://files.pythonhosted.org/packages/a5/80/df28131379eed93d9e6e6fccd3bf6e3d077bebbfe98cc83f21bbcd83ed02/fonttools-4.62.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:2d850f66830a27b0d498ee05adb13a3781637b1826982cd7e2b3789ef0cc71ae", size = 5031712, upload-time = "2026-03-13T13:52:25.14Z" }, + { url = "https://files.pythonhosted.org/packages/3d/03/3c8f09aad64230cd6d921ae7a19f9603c36f70930b00459f112706f6769a/fonttools-4.62.1-cp310-cp310-win32.whl", hash = "sha256:486f32c8047ccd05652aba17e4a8819a3a9d78570eb8a0e3b4503142947880ed", size = 1507878, upload-time = "2026-03-13T13:52:28.149Z" }, + { url = "https://files.pythonhosted.org/packages/dd/ec/f53f626f8f3e89f4cadd8fc08f3452c8fd182c951ad5caa35efac22b29ab/fonttools-4.62.1-cp310-cp310-win_amd64.whl", hash = "sha256:5a648bde915fba9da05ae98856987ca91ba832949a9e2888b48c47ef8b96c5a9", size = 1556766, upload-time = "2026-03-13T13:52:30.814Z" }, + { url = "https://files.pythonhosted.org/packages/88/39/23ff32561ec8d45a4d48578b4d241369d9270dc50926c017570e60893701/fonttools-4.62.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:40975849bac44fb0b9253d77420c6d8b523ac4dcdcefeff6e4d706838a5b80f7", size = 2871039, upload-time = "2026-03-13T13:52:33.127Z" }, + { url = "https://files.pythonhosted.org/packages/24/7f/66d3f8a9338a9b67fe6e1739f47e1cd5cee78bd3bc1206ef9b0b982289a5/fonttools-4.62.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:9dde91633f77fa576879a0c76b1d89de373cae751a98ddf0109d54e173b40f14", size = 2416346, upload-time = "2026-03-13T13:52:35.676Z" }, + { url = "https://files.pythonhosted.org/packages/aa/53/5276ceba7bff95da7793a07c5284e1da901cf00341ce5e2f3273056c0cca/fonttools-4.62.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6acb4109f8bee00fec985c8c7afb02299e35e9c94b57287f3ea542f28bd0b0a7", size = 5100897, upload-time = "2026-03-13T13:52:38.102Z" }, + { url = "https://files.pythonhosted.org/packages/cc/a1/40a5c4d8e28b0851d53a8eeeb46fbd73c325a2a9a165f290a5ed90e6c597/fonttools-4.62.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1c5c25671ce8805e0d080e2ffdeca7f1e86778c5cbfbeae86d7f866d8830517b", size = 5071078, upload-time = "2026-03-13T13:52:41.305Z" }, + { url = "https://files.pythonhosted.org/packages/e3/be/d378fca4c65ea1956fee6d90ace6e861776809cbbc5af22388a090c3c092/fonttools-4.62.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a5d8825e1140f04e6c99bb7d37a9e31c172f3bc208afbe02175339e699c710e1", size = 5076908, upload-time = "2026-03-13T13:52:44.122Z" }, + { url = "https://files.pythonhosted.org/packages/f8/d9/ae6a1d0693a4185a84605679c8a1f719a55df87b9c6e8e817bfdd9ef5936/fonttools-4.62.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:268abb1cb221e66c014acc234e872b7870d8b5d4657a83a8f4205094c32d2416", size = 5202275, upload-time = "2026-03-13T13:52:46.591Z" }, + { url = "https://files.pythonhosted.org/packages/54/6c/af95d9c4efb15cabff22642b608342f2bd67137eea6107202d91b5b03184/fonttools-4.62.1-cp311-cp311-win32.whl", hash = "sha256:942b03094d7edbb99bdf1ae7e9090898cad7bf9030b3d21f33d7072dbcb51a53", size = 2293075, upload-time = "2026-03-13T13:52:48.711Z" }, + { url = "https://files.pythonhosted.org/packages/d3/97/bf54c5b3f2be34e1f143e6db838dfdc54f2ffa3e68c738934c82f3b2a08d/fonttools-4.62.1-cp311-cp311-win_amd64.whl", hash = "sha256:e8514f4924375f77084e81467e63238b095abda5107620f49421c368a6017ed2", size = 2344593, upload-time = "2026-03-13T13:52:50.725Z" }, + { url = "https://files.pythonhosted.org/packages/47/d4/dbacced3953544b9a93088cc10ef2b596d348c983d5c67a404fa41ec51ba/fonttools-4.62.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:90365821debbd7db678809c7491ca4acd1e0779b9624cdc6ddaf1f31992bf974", size = 2870219, upload-time = "2026-03-13T13:52:53.664Z" }, + { url = "https://files.pythonhosted.org/packages/66/9e/a769c8e99b81e5a87ab7e5e7236684de4e96246aae17274e5347d11ebd78/fonttools-4.62.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:12859ff0b47dd20f110804c3e0d0970f7b832f561630cd879969011541a464a9", size = 2414891, upload-time = "2026-03-13T13:52:56.493Z" }, + { url = "https://files.pythonhosted.org/packages/69/64/f19a9e3911968c37e1e620e14dfc5778299e1474f72f4e57c5ec771d9489/fonttools-4.62.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c125ffa00c3d9003cdaaf7f2c79e6e535628093e14b5de1dccb08859b680936", size = 5033197, upload-time = "2026-03-13T13:52:59.179Z" }, + { url = "https://files.pythonhosted.org/packages/9b/8a/99c8b3c3888c5c474c08dbfd7c8899786de9604b727fcefb055b42c84bba/fonttools-4.62.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:149f7d84afca659d1a97e39a4778794a2f83bf344c5ee5134e09995086cc2392", size = 4988768, upload-time = "2026-03-13T13:53:02.761Z" }, + { url = "https://files.pythonhosted.org/packages/d1/c6/0f904540d3e6ab463c1243a0d803504826a11604c72dd58c2949796a1762/fonttools-4.62.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0aa72c43a601cfa9273bb1ae0518f1acadc01ee181a6fc60cd758d7fdadffc04", size = 4971512, upload-time = "2026-03-13T13:53:05.678Z" }, + { url = "https://files.pythonhosted.org/packages/29/0b/5cbef6588dc9bd6b5c9ad6a4d5a8ca384d0cea089da31711bbeb4f9654a6/fonttools-4.62.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:19177c8d96c7c36359266e571c5173bcee9157b59cfc8cb0153c5673dc5a3a7d", size = 5122723, upload-time = "2026-03-13T13:53:08.662Z" }, + { url = "https://files.pythonhosted.org/packages/4a/47/b3a5342d381595ef439adec67848bed561ab7fdb1019fa522e82101b7d9c/fonttools-4.62.1-cp312-cp312-win32.whl", hash = "sha256:a24decd24d60744ee8b4679d38e88b8303d86772053afc29b19d23bb8207803c", size = 2281278, upload-time = "2026-03-13T13:53:10.998Z" }, + { url = "https://files.pythonhosted.org/packages/28/b1/0c2ab56a16f409c6c8a68816e6af707827ad5d629634691ff60a52879792/fonttools-4.62.1-cp312-cp312-win_amd64.whl", hash = "sha256:9e7863e10b3de72376280b515d35b14f5eeed639d1aa7824f4cf06779ec65e42", size = 2331414, upload-time = "2026-03-13T13:53:13.992Z" }, + { url = "https://files.pythonhosted.org/packages/3b/56/6f389de21c49555553d6a5aeed5ac9767631497ac836c4f076273d15bd72/fonttools-4.62.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:c22b1014017111c401469e3acc5433e6acf6ebcc6aa9efb538a533c800971c79", size = 2865155, upload-time = "2026-03-13T13:53:16.132Z" }, + { url = "https://files.pythonhosted.org/packages/03/c5/0e3966edd5ec668d41dfe418787726752bc07e2f5fd8c8f208615e61fa89/fonttools-4.62.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:68959f5fc58ed4599b44aad161c2837477d7f35f5f79402d97439974faebfebe", size = 2412802, upload-time = "2026-03-13T13:53:18.878Z" }, + { url = "https://files.pythonhosted.org/packages/52/94/e6ac4b44026de7786fe46e3bfa0c87e51d5d70a841054065d49cd62bb909/fonttools-4.62.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef46db46c9447103b8f3ff91e8ba009d5fe181b1920a83757a5762551e32bb68", size = 5013926, upload-time = "2026-03-13T13:53:21.379Z" }, + { url = "https://files.pythonhosted.org/packages/e2/98/8b1e801939839d405f1f122e7d175cebe9aeb4e114f95bfc45e3152af9a7/fonttools-4.62.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6706d1cb1d5e6251a97ad3c1b9347505c5615c112e66047abbef0f8545fa30d1", size = 4964575, upload-time = "2026-03-13T13:53:23.857Z" }, + { url = "https://files.pythonhosted.org/packages/46/76/7d051671e938b1881670528fec69cc4044315edd71a229c7fd712eaa5119/fonttools-4.62.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2e7abd2b1e11736f58c1de27819e1955a53267c21732e78243fa2fa2e5c1e069", size = 4953693, upload-time = "2026-03-13T13:53:26.569Z" }, + { url = "https://files.pythonhosted.org/packages/1f/ae/b41f8628ec0be3c1b934fc12b84f4576a5c646119db4d3bdd76a217c90b5/fonttools-4.62.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:403d28ce06ebfc547fbcb0cb8b7f7cc2f7a2d3e1a67ba9a34b14632df9e080f9", size = 5094920, upload-time = "2026-03-13T13:53:29.329Z" }, + { url = "https://files.pythonhosted.org/packages/f2/f6/53a1e9469331a23dcc400970a27a4caa3d9f6edbf5baab0260285238b884/fonttools-4.62.1-cp313-cp313-win32.whl", hash = "sha256:93c316e0f5301b2adbe6a5f658634307c096fd5aae60a5b3412e4f3e1728ab24", size = 2279928, upload-time = "2026-03-13T13:53:32.352Z" }, + { url = "https://files.pythonhosted.org/packages/38/60/35186529de1db3c01f5ad625bde07c1f576305eab6d86bbda4c58445f721/fonttools-4.62.1-cp313-cp313-win_amd64.whl", hash = "sha256:7aa21ff53e28a9c2157acbc44e5b401149d3c9178107130e82d74ceb500e5056", size = 2330514, upload-time = "2026-03-13T13:53:34.991Z" }, + { url = "https://files.pythonhosted.org/packages/36/f0/2888cdac391807d68d90dcb16ef858ddc1b5309bfc6966195a459dd326e2/fonttools-4.62.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fa1d16210b6b10a826d71bed68dd9ec24a9e218d5a5e2797f37c573e7ec215ca", size = 2864442, upload-time = "2026-03-13T13:53:37.509Z" }, + { url = "https://files.pythonhosted.org/packages/4b/b2/e521803081f8dc35990816b82da6360fa668a21b44da4b53fc9e77efcd62/fonttools-4.62.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:aa69d10ed420d8121118e628ad47d86e4caa79ba37f968597b958f6cceab7eca", size = 2410901, upload-time = "2026-03-13T13:53:40.55Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/8c3511ff06e53110039358dbbdc1a65d72157a054638387aa2ada300a8b8/fonttools-4.62.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd13b7999d59c5eb1c2b442eb2d0c427cb517a0b7a1f5798fc5c9e003f5ff782", size = 4999608, upload-time = "2026-03-13T13:53:42.798Z" }, + { url = "https://files.pythonhosted.org/packages/28/63/cd0c3b26afe60995a5295f37c246a93d454023726c3261cfbb3559969bb9/fonttools-4.62.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8d337fdd49a79b0d51c4da87bc38169d21c3abbf0c1aa9367eff5c6656fb6dae", size = 4912726, upload-time = "2026-03-13T13:53:45.405Z" }, + { url = "https://files.pythonhosted.org/packages/70/b9/ac677cb07c24c685cf34f64e140617d58789d67a3dd524164b63648c6114/fonttools-4.62.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:d241cdc4a67b5431c6d7f115fdf63335222414995e3a1df1a41e1182acd4bcc7", size = 4951422, upload-time = "2026-03-13T13:53:48.326Z" }, + { url = "https://files.pythonhosted.org/packages/e6/10/11c08419a14b85b7ca9a9faca321accccc8842dd9e0b1c8a72908de05945/fonttools-4.62.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c05557a78f8fa514da0f869556eeda40887a8abc77c76ee3f74cf241778afd5a", size = 5060979, upload-time = "2026-03-13T13:53:51.366Z" }, + { url = "https://files.pythonhosted.org/packages/4e/3c/12eea4a4cf054e7ab058ed5ceada43b46809fce2bf319017c4d63ae55bb4/fonttools-4.62.1-cp314-cp314-win32.whl", hash = "sha256:49a445d2f544ce4a69338694cad575ba97b9a75fff02720da0882d1a73f12800", size = 2283733, upload-time = "2026-03-13T13:53:53.606Z" }, + { url = "https://files.pythonhosted.org/packages/6b/67/74b070029043186b5dd13462c958cb7c7f811be0d2e634309d9a1ffb1505/fonttools-4.62.1-cp314-cp314-win_amd64.whl", hash = "sha256:1eecc128c86c552fb963fe846ca4e011b1be053728f798185a1687502f6d398e", size = 2335663, upload-time = "2026-03-13T13:53:56.23Z" }, + { url = "https://files.pythonhosted.org/packages/42/c5/4d2ed3ca6e33617fc5624467da353337f06e7f637707478903c785bd8e20/fonttools-4.62.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:1596aeaddf7f78e21e68293c011316a25267b3effdaccaf4d59bc9159d681b82", size = 2947288, upload-time = "2026-03-13T13:53:59.397Z" }, + { url = "https://files.pythonhosted.org/packages/1f/e9/7ab11ddfda48ed0f89b13380e5595ba572619c27077be0b2c447a63ff351/fonttools-4.62.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:8f8fca95d3bb3208f59626a4b0ea6e526ee51f5a8ad5d91821c165903e8d9260", size = 2449023, upload-time = "2026-03-13T13:54:01.642Z" }, + { url = "https://files.pythonhosted.org/packages/b2/10/a800fa090b5e8819942e54e19b55fc7c21fe14a08757c3aa3ca8db358939/fonttools-4.62.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee91628c08e76f77b533d65feb3fbe6d9dad699f95be51cf0d022db94089cdc4", size = 5137599, upload-time = "2026-03-13T13:54:04.495Z" }, + { url = "https://files.pythonhosted.org/packages/37/dc/8ccd45033fffd74deb6912fa1ca524643f584b94c87a16036855b498a1ed/fonttools-4.62.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5f37df1cac61d906e7b836abe356bc2f34c99d4477467755c216b72aa3dc748b", size = 4920933, upload-time = "2026-03-13T13:54:07.557Z" }, + { url = "https://files.pythonhosted.org/packages/99/eb/e618adefb839598d25ac8136cd577925d6c513dc0d931d93b8af956210f0/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:92bb00a947e666169c99b43753c4305fc95a890a60ef3aeb2a6963e07902cc87", size = 5016232, upload-time = "2026-03-13T13:54:10.611Z" }, + { url = "https://files.pythonhosted.org/packages/d9/5f/9b5c9bfaa8ec82def8d8168c4f13615990d6ce5996fe52bd49bfb5e05134/fonttools-4.62.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:bdfe592802ef939a0e33106ea4a318eeb17822c7ee168c290273cbd5fabd746c", size = 5042987, upload-time = "2026-03-13T13:54:13.569Z" }, + { url = "https://files.pythonhosted.org/packages/90/aa/dfbbe24c6a6afc5c203d90cc0343e24bcbb09e76d67c4d6eef8c2558d7ba/fonttools-4.62.1-cp314-cp314t-win32.whl", hash = "sha256:b820fcb92d4655513d8402d5b219f94481c4443d825b4372c75a2072aa4b357a", size = 2348021, upload-time = "2026-03-13T13:54:16.98Z" }, + { url = "https://files.pythonhosted.org/packages/13/6f/ae9c4e4dd417948407b680855c2c7790efb52add6009aaecff1e3bc50e8e/fonttools-4.62.1-cp314-cp314t-win_amd64.whl", hash = "sha256:59b372b4f0e113d3746b88985f1c796e7bf830dd54b28374cd85c2b8acd7583e", size = 2414147, upload-time = "2026-03-13T13:54:19.416Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ba/56147c165442cc5ba7e82ecf301c9a68353cede498185869e6e02b4c264f/fonttools-4.62.1-py3-none-any.whl", hash = "sha256:7487782e2113861f4ddcc07c3436450659e3caa5e470b27dc2177cade2d8e7fd", size = 1152647, upload-time = "2026-03-13T13:54:22.735Z" }, +] + +[[package]] +name = "gymnasium" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cloudpickle" }, + { name = "farama-notifications" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/90/69/70cd29e9fc4953d013b15981ee71d4c9ef4d8b2183e6ef2fe89756746dce/gymnasium-1.1.1.tar.gz", hash = "sha256:8bd9ea9bdef32c950a444ff36afc785e1d81051ec32d30435058953c20d2456d", size = 829326, upload-time = "2025-03-06T16:30:36.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f9/68/2bdc7b46b5f543dd865575f9d19716866bdb76e50dd33b71ed1a3dd8bb42/gymnasium-1.1.1-py3-none-any.whl", hash = "sha256:9c167ec0a2b388666e37f63b2849cd2552f7f5b71938574c637bb36487eb928a", size = 965410, upload-time = "2025-03-06T16:30:34.443Z" }, +] + +[[package]] +name = "imageio" +version = "2.37.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "pillow" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/b1/84/93bcd1300216ea50811cee96873b84a1bebf8d0489ffaf7f2a3756bab866/imageio-2.37.3.tar.gz", hash = "sha256:bbb37efbfc4c400fcd534b367b91fcd66d5da639aaa138034431a1c5e0a41451", size = 389673, upload-time = "2026-03-09T11:31:12.573Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/49/fa/391e437a34e55095173dca5f24070d89cbc233ff85bf1c29c93248c6588d/imageio-2.37.3-py3-none-any.whl", hash = "sha256:46f5bb8522cd421c0f5ae104d8268f569d856b29eb1a13b92829d1970f32c9f0", size = 317646, upload-time = "2026-03-09T11:31:10.771Z" }, +] + +[package.optional-dependencies] +ffmpeg = [ + { name = "imageio-ffmpeg" }, + { name = "psutil" }, +] + +[[package]] +name = "imageio-ffmpeg" +version = "0.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/44/bd/c3343c721f2a1b0c9fc71c1aebf1966a3b7f08c2eea8ed5437a2865611d6/imageio_ffmpeg-0.6.0.tar.gz", hash = "sha256:e2556bed8e005564a9f925bb7afa4002d82770d6b08825078b7697ab88ba1755", size = 25210, upload-time = "2025-01-16T21:34:32.747Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/da/58/87ef68ac83f4c7690961bce288fd8e382bc5f1513860fc7f90a9c1c1c6bf/imageio_ffmpeg-0.6.0-py3-none-macosx_10_9_intel.macosx_10_9_x86_64.whl", hash = "sha256:9d2baaf867088508d4a3458e61eeb30e945c4ad8016025545f66c4b5aaef0a61", size = 24932969, upload-time = "2025-01-16T21:34:20.464Z" }, + { url = "https://files.pythonhosted.org/packages/40/5c/f3d8a657d362cc93b81aab8feda487317da5b5d31c0e1fdfd5e986e55d17/imageio_ffmpeg-0.6.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:b1ae3173414b5fc5f538a726c4e48ea97edc0d2cdc11f103afee655c463fa742", size = 21113891, upload-time = "2025-01-16T21:34:00.277Z" }, + { url = "https://files.pythonhosted.org/packages/33/e7/1925bfbc563c39c1d2e82501d8372734a5c725e53ac3b31b4c2d081e895b/imageio_ffmpeg-0.6.0-py3-none-manylinux2014_aarch64.whl", hash = "sha256:1d47bebd83d2c5fc770720d211855f208af8a596c82d17730aa51e815cdee6dc", size = 25632706, upload-time = "2025-01-16T21:33:53.475Z" }, + { url = "https://files.pythonhosted.org/packages/a0/2d/43c8522a2038e9d0e7dbdf3a61195ecc31ca576fb1527a528c877e87d973/imageio_ffmpeg-0.6.0-py3-none-manylinux2014_x86_64.whl", hash = "sha256:c7e46fcec401dd990405049d2e2f475e2b397779df2519b544b8aab515195282", size = 29498237, upload-time = "2025-01-16T21:34:13.726Z" }, + { url = "https://files.pythonhosted.org/packages/a0/13/59da54728351883c3c1d9fca1710ab8eee82c7beba585df8f25ca925f08f/imageio_ffmpeg-0.6.0-py3-none-win32.whl", hash = "sha256:196faa79366b4a82f95c0f4053191d2013f4714a715780f0ad2a68ff37483cc2", size = 19652251, upload-time = "2025-01-16T21:34:06.812Z" }, + { url = "https://files.pythonhosted.org/packages/2c/c6/fa760e12a2483469e2bf5058c5faff664acf66cadb4df2ad6205b016a73d/imageio_ffmpeg-0.6.0-py3-none-win_amd64.whl", hash = "sha256:02fa47c83703c37df6bfe4896aab339013f62bf02c5ebf2dce6da56af04ffc0a", size = 31246824, upload-time = "2025-01-16T21:34:28.6Z" }, +] + +[[package]] +name = "iniconfig" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/34/14ca021ce8e5dfedc35312d08ba8bf51fdd999c576889fc2c24cb97f4f10/iniconfig-2.3.0.tar.gz", hash = "sha256:c76315c77db068650d49c5b56314774a7804df16fee4402c1f19d6d15d8c4730", size = 20503, upload-time = "2025-10-18T21:55:43.219Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/b1/3846dd7f199d53cb17f49cba7e651e9ce294d8497c8c150530ed11865bb8/iniconfig-2.3.0-py3-none-any.whl", hash = "sha256:f631c04d2c48c52b84d0d0549c99ff3859c98df65b3101406327ecc7d53fbf12", size = 7484, upload-time = "2025-10-18T21:55:41.639Z" }, +] + +[[package]] +name = "ipykernel" +version = "7.2.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython", version = "8.39.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "ipython", version = "9.13.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "matplotlib-inline" }, + { name = "nest-asyncio" }, + { name = "packaging" }, + { name = "psutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/82/b9/e73d5d9f405cba7706c539aa8b311b49d4c2f3d698d9c12f815231169c71/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661", size = 118788, upload-time = "2026-02-06T16:43:25.149Z" }, +] + +[[package]] +name = "ipython" +version = "8.39.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version < '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version < '3.11'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "jedi", marker = "python_full_version < '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version < '3.11'" }, + { name = "pexpect", marker = "python_full_version < '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version < '3.11'" }, + { name = "pygments", marker = "python_full_version < '3.11'" }, + { name = "stack-data", marker = "python_full_version < '3.11'" }, + { name = "traitlets", marker = "python_full_version < '3.11'" }, + { name = "typing-extensions", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/40/18/f8598d287006885e7136451fdea0755af4ebcbfe342836f24deefaed1164/ipython-8.39.0.tar.gz", hash = "sha256:4110ae96012c379b8b6db898a07e186c40a2a1ef5d57a7fa83166047d9da7624", size = 5513971, upload-time = "2026-03-27T10:02:13.94Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/c0/56/4cc7fc9e9e3f38fd324f24f8afe0ad8bb5fa41283f37f1aaf9de0612c968/ipython-8.39.0-py3-none-any.whl", hash = "sha256:bb3c51c4fa8148ab1dea07a79584d1c854e234ea44aa1283bcb37bc75054651f", size = 831849, upload-time = "2026-03-27T10:02:07.846Z" }, +] + +[[package]] +name = "ipython" +version = "9.13.0" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +dependencies = [ + { name = "colorama", marker = "python_full_version >= '3.11' and sys_platform == 'win32'" }, + { name = "decorator", marker = "python_full_version >= '3.11'" }, + { name = "ipython-pygments-lexers", marker = "python_full_version >= '3.11'" }, + { name = "jedi", marker = "python_full_version >= '3.11'" }, + { name = "matplotlib-inline", marker = "python_full_version >= '3.11'" }, + { name = "pexpect", marker = "python_full_version >= '3.11' and sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit", marker = "python_full_version >= '3.11'" }, + { name = "psutil", marker = "python_full_version >= '3.11'" }, + { name = "pygments", marker = "python_full_version >= '3.11'" }, + { name = "stack-data", marker = "python_full_version >= '3.11'" }, + { name = "traitlets", marker = "python_full_version >= '3.11'" }, + { name = "typing-extensions", marker = "python_full_version == '3.11.*'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", hash = "sha256:7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967", size = 4430549, upload-time = "2026-04-24T12:24:55.221Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b9/86/3060e8029b7cc505cce9a0137431dda81d0a3fde93a8f0f50ee0bf37a795/ipython-9.13.0-py3-none-any.whl", hash = "sha256:57f9d4639e20818d328d287c7b549af3d05f12486ea8f2e7f73e52a36ec4d201", size = 627274, upload-time = "2026-04-24T12:24:53.038Z" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "pygments", marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d9/33/1f075bf72b0b747cb3288d011319aaf64083cf2efef8354174e3ed4540e2/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c", size = 8074, upload-time = "2025-01-17T11:24:33.271Z" }, +] + +[[package]] +name = "isort" +version = "8.0.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/ef/7c/ec4ab396d31b3b395e2e999c8f46dec78c5e29209fac49d1f4dace04041d/isort-8.0.1.tar.gz", hash = "sha256:171ac4ff559cdc060bcfff550bc8404a486fee0caab245679c2abe7cb253c78d", size = 769592, upload-time = "2026-02-28T10:08:20.685Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3e/95/c7c34aa53c16353c56d0b802fba48d5f5caa2cdee7958acbcb795c830416/isort-8.0.1-py3-none-any.whl", hash = "sha256:28b89bc70f751b559aeca209e6120393d43fbe2490de0559662be7a9787e3d75", size = 89733, upload-time = "2026-02-28T10:08:19.466Z" }, +] + +[[package]] +name = "jedi" +version = "0.20.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/93/242e2eab5fe682ffcb8b0084bde703a41d51e17ee0f3a31ff0d9d813620a/jedi-0.20.0-py2.py3-none-any.whl", hash = "sha256:7bdd9c2634f56713299976f4cbd59cb3fa92165cc5e05ea811fb253480728b67", size = 4884812, upload-time = "2026-05-01T23:38:43.919Z" }, +] + +[[package]] +name = "jupyter-client" +version = "8.8.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/2d/0b/ceb7694d864abc0a047649aec263878acb9f792e1fec3e676f22dc9015e3/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a", size = 107371, upload-time = "2026-01-08T13:55:45.562Z" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e7/e7/80988e32bf6f73919a113473a604f5a8f09094de312b9d52b79c2df7612b/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407", size = 29032, upload-time = "2025-10-16T19:19:16.783Z" }, +] + +[[package]] +name = "kiwisolver" +version = "1.5.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/d0/67/9c61eccb13f0bdca9307614e782fec49ffdde0f7a2314935d489fa93cd9c/kiwisolver-1.5.0.tar.gz", hash = "sha256:d4193f3d9dc3f6f79aaed0e5637f45d98850ebf01f7ca20e69457f3e8946b66a", size = 103482, upload-time = "2026-03-09T13:15:53.382Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ac/f8/06549565caa026e540b7e7bab5c5a90eb7ca986015f4c48dace243cd24d9/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:32cc0a5365239a6ea0c6ed461e8838d053b57e397443c0ca894dcc8e388d4374", size = 122802, upload-time = "2026-03-09T13:12:37.515Z" }, + { url = "https://files.pythonhosted.org/packages/84/eb/8476a0818850c563ff343ea7c9c05dcdcbd689a38e01aa31657df01f91fa/kiwisolver-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cc0b66c1eec9021353a4b4483afb12dfd50e3669ffbb9152d6842eb34c7e29fd", size = 66216, upload-time = "2026-03-09T13:12:38.812Z" }, + { url = "https://files.pythonhosted.org/packages/f3/c4/f9c8a6b4c21aed4198566e45923512986d6cef530e7263b3a5f823546561/kiwisolver-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:86e0287879f75621ae85197b0877ed2f8b7aa57b511c7331dce2eb6f4de7d476", size = 63917, upload-time = "2026-03-09T13:12:40.053Z" }, + { url = "https://files.pythonhosted.org/packages/f1/0e/ba4ae25d03722f64de8b2c13e80d82ab537a06b30fc7065183c6439357e3/kiwisolver-1.5.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:62f59da443c4f4849f73a51a193b1d9d258dcad0c41bc4d1b8fb2bcc04bfeb22", size = 1628776, upload-time = "2026-03-09T13:12:41.976Z" }, + { url = "https://files.pythonhosted.org/packages/8a/e4/3f43a011bc8a0860d1c96f84d32fa87439d3feedf66e672fef03bf5e8bac/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9190426b7aa26c5229501fa297b8d0653cfd3f5a36f7990c264e157cbf886b3b", size = 1228164, upload-time = "2026-03-09T13:12:44.002Z" }, + { url = "https://files.pythonhosted.org/packages/4b/34/3a901559a1e0c218404f9a61a93be82d45cb8f44453ba43088644980f033/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c8277104ded0a51e699c8c3aff63ce2c56d4ed5519a5f73e0fd7057f959a2b9e", size = 1246656, upload-time = "2026-03-09T13:12:45.557Z" }, + { url = "https://files.pythonhosted.org/packages/87/9e/f78c466ea20527822b95ad38f141f2de1dcd7f23fb8716b002b0d91bbe59/kiwisolver-1.5.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8f9baf6f0a6e7571c45c8863010b45e837c3ee1c2c77fcd6ef423be91b21fedb", size = 1295562, upload-time = "2026-03-09T13:12:47.562Z" }, + { url = "https://files.pythonhosted.org/packages/0a/66/fd0e4a612e3a286c24e6d6f3a5428d11258ed1909bc530ba3b59807fd980/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:cff8e5383db4989311f99e814feeb90c4723eb4edca425b9d5d9c3fefcdd9537", size = 2178473, upload-time = "2026-03-09T13:12:50.254Z" }, + { url = "https://files.pythonhosted.org/packages/dc/8e/6cac929e0049539e5ee25c1ee937556f379ba5204840d03008363ced662d/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ebae99ed6764f2b5771c522477b311be313e8841d2e0376db2b10922daebbba4", size = 2274035, upload-time = "2026-03-09T13:12:51.785Z" }, + { url = "https://files.pythonhosted.org/packages/ca/d3/9d0c18f1b52ea8074b792452cf17f1f5a56bd0302a85191f405cfbf9da16/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:d5cd5189fc2b6a538b75ae45433140c4823463918f7b1617c31e68b085c0022c", size = 2443217, upload-time = "2026-03-09T13:12:53.329Z" }, + { url = "https://files.pythonhosted.org/packages/45/2a/6e19368803a038b2a90857bf4ee9e3c7b667216d045866bf22d3439fd75e/kiwisolver-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f42c23db5d1521218a3276bb08666dcb662896a0be7347cba864eca45ff64ede", size = 2249196, upload-time = "2026-03-09T13:12:55.057Z" }, + { url = "https://files.pythonhosted.org/packages/75/2b/3f641dfcbe72e222175d626bacf2f72c3b34312afec949dd1c50afa400f5/kiwisolver-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:94eff26096eb5395136634622515b234ecb6c9979824c1f5004c6e3c3c85ccd2", size = 73389, upload-time = "2026-03-09T13:12:56.496Z" }, + { url = "https://files.pythonhosted.org/packages/da/88/299b137b9e0025d8982e03d2d52c123b0a2b159e84b0ef1501ef446339cf/kiwisolver-1.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:dd952e03bfbb096cfe2dd35cd9e00f269969b67536cb4370994afc20ff2d0875", size = 64782, upload-time = "2026-03-09T13:12:57.609Z" }, + { url = "https://files.pythonhosted.org/packages/12/dd/a495a9c104be1c476f0386e714252caf2b7eca883915422a64c50b88c6f5/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:9eed0f7edbb274413b6ee781cca50541c8c0facd3d6fd289779e494340a2b85c", size = 122798, upload-time = "2026-03-09T13:12:58.963Z" }, + { url = "https://files.pythonhosted.org/packages/11/60/37b4047a2af0cf5ef6d8b4b26e91829ae6fc6a2d1f74524bcb0e7cd28a32/kiwisolver-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:3c4923e404d6bcd91b6779c009542e5647fef32e4a5d75e115e3bbac6f2335eb", size = 66216, upload-time = "2026-03-09T13:13:00.155Z" }, + { url = "https://files.pythonhosted.org/packages/0a/aa/510dc933d87767584abfe03efa445889996c70c2990f6f87c3ebaa0a18c5/kiwisolver-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0df54df7e686afa55e6f21fb86195224a6d9beb71d637e8d7920c95cf0f89aac", size = 63911, upload-time = "2026-03-09T13:13:01.671Z" }, + { url = "https://files.pythonhosted.org/packages/80/46/bddc13df6c2a40741e0cc7865bb1c9ed4796b6760bd04ce5fae3928ef917/kiwisolver-1.5.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2517e24d7315eb51c10664cdb865195df38ab74456c677df67bb47f12d088a27", size = 1438209, upload-time = "2026-03-09T13:13:03.385Z" }, + { url = "https://files.pythonhosted.org/packages/fd/d6/76621246f5165e5372f02f5e6f3f48ea336a8f9e96e43997d45b240ed8cd/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff710414307fefa903e0d9bdf300972f892c23477829f49504e59834f4195398", size = 1248888, upload-time = "2026-03-09T13:13:05.231Z" }, + { url = "https://files.pythonhosted.org/packages/b2/c1/31559ec6fb39a5b48035ce29bb63ade628f321785f38c384dee3e2c08bc1/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6176c1811d9d5a04fa391c490cc44f451e240697a16977f11c6f722efb9041db", size = 1266304, upload-time = "2026-03-09T13:13:06.743Z" }, + { url = "https://files.pythonhosted.org/packages/5e/ef/1cb8276f2d29cc6a41e0a042f27946ca347d3a4a75acf85d0a16aa6dcc82/kiwisolver-1.5.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50847dca5d197fcbd389c805aa1a1cf32f25d2e7273dc47ab181a517666b68cc", size = 1319650, upload-time = "2026-03-09T13:13:08.607Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e4/5ba3cecd7ce6236ae4a80f67e5d5531287337d0e1f076ca87a5abe4cd5d0/kiwisolver-1.5.0-cp311-cp311-manylinux_2_39_riscv64.whl", hash = "sha256:01808c6d15f4c3e8559595d6d1fe6411c68e4a3822b4b9972b44473b24f4e679", size = 970949, upload-time = "2026-03-09T13:13:10.299Z" }, + { url = "https://files.pythonhosted.org/packages/5a/69/dc61f7ae9a2f071f26004ced87f078235b5507ab6e5acd78f40365655034/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:f1f9f4121ec58628c96baa3de1a55a4e3a333c5102c8e94b64e23bf7b2083309", size = 2199125, upload-time = "2026-03-09T13:13:11.841Z" }, + { url = "https://files.pythonhosted.org/packages/e5/7b/abbe0f1b5afa85f8d084b73e90e5f801c0939eba16ac2e49af7c61a6c28d/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:b7d335370ae48a780c6e6a6bbfa97342f563744c39c35562f3f367665f5c1de2", size = 2293783, upload-time = "2026-03-09T13:13:14.399Z" }, + { url = "https://files.pythonhosted.org/packages/8a/80/5908ae149d96d81580d604c7f8aefd0e98f4fd728cf172f477e9f2a81744/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:800ee55980c18545af444d93fdd60c56b580db5cc54867d8cbf8a1dc0829938c", size = 1960726, upload-time = "2026-03-09T13:13:16.047Z" }, + { url = "https://files.pythonhosted.org/packages/84/08/a78cb776f8c085b7143142ce479859cfec086bd09ee638a317040b6ef420/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:c438f6ca858697c9ab67eb28246c92508af972e114cac34e57a6d4ba17a3ac08", size = 2464738, upload-time = "2026-03-09T13:13:17.897Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e1/65584da5356ed6cb12c63791a10b208860ac40a83de165cb6a6751a686e3/kiwisolver-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:8c63c91f95173f9c2a67c7c526b2cea976828a0e7fced9cdcead2802dc10f8a4", size = 2270718, upload-time = "2026-03-09T13:13:19.421Z" }, + { url = "https://files.pythonhosted.org/packages/be/6c/28f17390b62b8f2f520e2915095b3c94d88681ecf0041e75389d9667f202/kiwisolver-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:beb7f344487cdcb9e1efe4b7a29681b74d34c08f0043a327a74da852a6749e7b", size = 73480, upload-time = "2026-03-09T13:13:20.818Z" }, + { url = "https://files.pythonhosted.org/packages/d8/0e/2ee5debc4f77a625778fec5501ff3e8036fe361b7ee28ae402a485bb9694/kiwisolver-1.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:ad4ae4ffd1ee9cd11357b4c66b612da9888f4f4daf2f36995eda64bd45370cac", size = 64930, upload-time = "2026-03-09T13:13:21.997Z" }, + { url = "https://files.pythonhosted.org/packages/4d/b2/818b74ebea34dabe6d0c51cb1c572e046730e64844da6ed646d5298c40ce/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4e9750bc21b886308024f8a54ccb9a2cc38ac9fa813bf4348434e3d54f337ff9", size = 123158, upload-time = "2026-03-09T13:13:23.127Z" }, + { url = "https://files.pythonhosted.org/packages/bf/d9/405320f8077e8e1c5c4bd6adc45e1e6edf6d727b6da7f2e2533cf58bff71/kiwisolver-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:72ec46b7eba5b395e0a7b63025490d3214c11013f4aacb4f5e8d6c3041829588", size = 66388, upload-time = "2026-03-09T13:13:24.765Z" }, + { url = "https://files.pythonhosted.org/packages/99/9f/795fedf35634f746151ca8839d05681ceb6287fbed6cc1c9bf235f7887c2/kiwisolver-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ed3a984b31da7481b103f68776f7128a89ef26ed40f4dc41a2223cda7fb24819", size = 64068, upload-time = "2026-03-09T13:13:25.878Z" }, + { url = "https://files.pythonhosted.org/packages/c4/13/680c54afe3e65767bed7ec1a15571e1a2f1257128733851ade24abcefbcc/kiwisolver-1.5.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:bb5136fb5352d3f422df33f0c879a1b0c204004324150cc3b5e3c4f310c9049f", size = 1477934, upload-time = "2026-03-09T13:13:27.166Z" }, + { url = "https://files.pythonhosted.org/packages/c8/2f/cebfcdb60fd6a9b0f6b47a9337198bcbad6fbe15e68189b7011fd914911f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b2af221f268f5af85e776a73d62b0845fc8baf8ef0abfae79d29c77d0e776aaf", size = 1278537, upload-time = "2026-03-09T13:13:28.707Z" }, + { url = "https://files.pythonhosted.org/packages/f2/0d/9b782923aada3fafb1d6b84e13121954515c669b18af0c26e7d21f579855/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b0f172dc8ffaccb8522d7c5d899de00133f2f1ca7b0a49b7da98e901de87bf2d", size = 1296685, upload-time = "2026-03-09T13:13:30.528Z" }, + { url = "https://files.pythonhosted.org/packages/27/70/83241b6634b04fe44e892688d5208332bde130f38e610c0418f9ede47ded/kiwisolver-1.5.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6ab8ba9152203feec73758dad83af9a0bbe05001eb4639e547207c40cfb52083", size = 1346024, upload-time = "2026-03-09T13:13:32.818Z" }, + { url = "https://files.pythonhosted.org/packages/e4/db/30ed226fb271ae1a6431fc0fe0edffb2efe23cadb01e798caeb9f2ceae8f/kiwisolver-1.5.0-cp312-cp312-manylinux_2_39_riscv64.whl", hash = "sha256:cdee07c4d7f6d72008d3f73b9bf027f4e11550224c7c50d8df1ae4a37c1402a6", size = 987241, upload-time = "2026-03-09T13:13:34.435Z" }, + { url = "https://files.pythonhosted.org/packages/ec/bd/c314595208e4c9587652d50959ead9e461995389664e490f4dce7ff0f782/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7c60d3c9b06fb23bd9c6139281ccbdc384297579ae037f08ae90c69f6845c0b1", size = 2227742, upload-time = "2026-03-09T13:13:36.4Z" }, + { url = "https://files.pythonhosted.org/packages/c1/43/0499cec932d935229b5543d073c2b87c9c22846aab48881e9d8d6e742a2d/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e315e5ec90d88e140f57696ff85b484ff68bb311e36f2c414aa4286293e6dee0", size = 2323966, upload-time = "2026-03-09T13:13:38.204Z" }, + { url = "https://files.pythonhosted.org/packages/3d/6f/79b0d760907965acfd9d61826a3d41f8f093c538f55cd2633d3f0db269f6/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:1465387ac63576c3e125e5337a6892b9e99e0627d52317f3ca79e6930d889d15", size = 1977417, upload-time = "2026-03-09T13:13:39.966Z" }, + { url = "https://files.pythonhosted.org/packages/ab/31/01d0537c41cb75a551a438c3c7a80d0c60d60b81f694dac83dd436aec0d0/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:530a3fd64c87cffa844d4b6b9768774763d9caa299e9b75d8eca6a4423b31314", size = 2491238, upload-time = "2026-03-09T13:13:41.698Z" }, + { url = "https://files.pythonhosted.org/packages/e4/34/8aefdd0be9cfd00a44509251ba864f5caf2991e36772e61c408007e7f417/kiwisolver-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:1d9daea4ea6b9be74fe2f01f7fbade8d6ffab263e781274cffca0dba9be9eec9", size = 2294947, upload-time = "2026-03-09T13:13:43.343Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/0348374369ca588f8fe9c338fae49fa4e16eeb10ffb3d012f23a54578a9e/kiwisolver-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:f18c2d9782259a6dc132fdc7a63c168cbc74b35284b6d75c673958982a378384", size = 73569, upload-time = "2026-03-09T13:13:45.792Z" }, + { url = "https://files.pythonhosted.org/packages/28/26/192b26196e2316e2bd29deef67e37cdf9870d9af8e085e521afff0fed526/kiwisolver-1.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:f7c7553b13f69c1b29a5bde08ddc6d9d0c8bfb84f9ed01c30db25944aeb852a7", size = 64997, upload-time = "2026-03-09T13:13:46.878Z" }, + { url = "https://files.pythonhosted.org/packages/9d/69/024d6711d5ba575aa65d5538042e99964104e97fa153a9f10bc369182bc2/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:fd40bb9cd0891c4c3cb1ddf83f8bbfa15731a248fdc8162669405451e2724b09", size = 123166, upload-time = "2026-03-09T13:13:48.032Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/adbb40df306f587054a348831220812b9b1d787aff714cfbc8556e38fccd/kiwisolver-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c0e1403fd7c26d77c1f03e096dc58a5c726503fa0db0456678b8668f76f521e3", size = 66395, upload-time = "2026-03-09T13:13:49.365Z" }, + { url = "https://files.pythonhosted.org/packages/a8/3a/d0a972b34e1c63e2409413104216cd1caa02c5a37cb668d1687d466c1c45/kiwisolver-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dda366d548e89a90d88a86c692377d18d8bd64b39c1fb2b92cb31370e2896bbd", size = 64065, upload-time = "2026-03-09T13:13:50.562Z" }, + { url = "https://files.pythonhosted.org/packages/2b/0a/7b98e1e119878a27ba8618ca1e18b14f992ff1eda40f47bccccf4de44121/kiwisolver-1.5.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:332b4f0145c30b5f5ad9374881133e5aa64320428a57c2c2b61e9d891a51c2f3", size = 1477903, upload-time = "2026-03-09T13:13:52.084Z" }, + { url = "https://files.pythonhosted.org/packages/18/d8/55638d89ffd27799d5cc3d8aa28e12f4ce7a64d67b285114dbedc8ea4136/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0c50b89ffd3e1a911c69a1dd3de7173c0cd10b130f56222e57898683841e4f96", size = 1278751, upload-time = "2026-03-09T13:13:54.673Z" }, + { url = "https://files.pythonhosted.org/packages/b8/97/b4c8d0d18421ecceba20ad8701358453b88e32414e6f6950b5a4bad54e65/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4db576bb8c3ef9365f8b40fe0f671644de6736ae2c27a2c62d7d8a1b4329f099", size = 1296793, upload-time = "2026-03-09T13:13:56.287Z" }, + { url = "https://files.pythonhosted.org/packages/c4/10/f862f94b6389d8957448ec9df59450b81bec4abb318805375c401a1e6892/kiwisolver-1.5.0-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0b85aad90cea8ac6797a53b5d5f2e967334fa4d1149f031c4537569972596cb8", size = 1346041, upload-time = "2026-03-09T13:13:58.269Z" }, + { url = "https://files.pythonhosted.org/packages/a3/6a/f1650af35821eaf09de398ec0bc2aefc8f211f0cda50204c9f1673741ba9/kiwisolver-1.5.0-cp313-cp313-manylinux_2_39_riscv64.whl", hash = "sha256:d36ca54cb4c6c4686f7cbb7b817f66f5911c12ddb519450bbe86707155028f87", size = 987292, upload-time = "2026-03-09T13:13:59.871Z" }, + { url = "https://files.pythonhosted.org/packages/de/19/d7fb82984b9238115fe629c915007be608ebd23dc8629703d917dbfaffd4/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:38f4a703656f493b0ad185211ccfca7f0386120f022066b018eb5296d8613e23", size = 2227865, upload-time = "2026-03-09T13:14:01.401Z" }, + { url = "https://files.pythonhosted.org/packages/7f/b9/46b7f386589fd222dac9e9de9c956ce5bcefe2ee73b4e79891381dda8654/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ac2360e93cb41be81121755c6462cff3beaa9967188c866e5fce5cf13170859", size = 2324369, upload-time = "2026-03-09T13:14:02.972Z" }, + { url = "https://files.pythonhosted.org/packages/92/8b/95e237cf3d9c642960153c769ddcbe278f182c8affb20cecc1cc983e7cc5/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c95cab08d1965db3d84a121f1c7ce7479bdd4072c9b3dafd8fecce48a2e6b902", size = 1977989, upload-time = "2026-03-09T13:14:04.503Z" }, + { url = "https://files.pythonhosted.org/packages/1b/95/980c9df53501892784997820136c01f62bc1865e31b82b9560f980c0e649/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:fc20894c3d21194d8041a28b65622d5b86db786da6e3cfe73f0c762951a61167", size = 2491645, upload-time = "2026-03-09T13:14:06.106Z" }, + { url = "https://files.pythonhosted.org/packages/cb/32/900647fd0840abebe1561792c6b31e6a7c0e278fc3973d30572a965ca14c/kiwisolver-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7a32f72973f0f950c1920475d5c5ea3d971b81b6f0ec53b8d0a956cc965f22e0", size = 2295237, upload-time = "2026-03-09T13:14:08.891Z" }, + { url = "https://files.pythonhosted.org/packages/be/8a/be60e3bbcf513cc5a50f4a3e88e1dcecebb79c1ad607a7222877becaa101/kiwisolver-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:0bf3acf1419fa93064a4c2189ac0b58e3be7872bf6ee6177b0d4c63dc4cea276", size = 73573, upload-time = "2026-03-09T13:14:12.327Z" }, + { url = "https://files.pythonhosted.org/packages/4d/d2/64be2e429eb4fca7f7e1c52a91b12663aeaf25de3895e5cca0f47ef2a8d0/kiwisolver-1.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:fa8eb9ecdb7efb0b226acec134e0d709e87a909fa4971a54c0c4f6e88635484c", size = 64998, upload-time = "2026-03-09T13:14:13.469Z" }, + { url = "https://files.pythonhosted.org/packages/b0/69/ce68dd0c85755ae2de490bf015b62f2cea5f6b14ff00a463f9d0774449ff/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:db485b3847d182b908b483b2ed133c66d88d49cacf98fd278fadafe11b4478d1", size = 125700, upload-time = "2026-03-09T13:14:14.636Z" }, + { url = "https://files.pythonhosted.org/packages/74/aa/937aac021cf9d4349990d47eb319309a51355ed1dbdc9c077cdc9224cb11/kiwisolver-1.5.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:be12f931839a3bdfe28b584db0e640a65a8bcbc24560ae3fdb025a449b3d754e", size = 67537, upload-time = "2026-03-09T13:14:15.808Z" }, + { url = "https://files.pythonhosted.org/packages/ee/20/3a87fbece2c40ad0f6f0aefa93542559159c5f99831d596050e8afae7a9f/kiwisolver-1.5.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:16b85d37c2cbb3253226d26e64663f755d88a03439a9c47df6246b35defbdfb7", size = 65514, upload-time = "2026-03-09T13:14:18.035Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7f/f943879cda9007c45e1f7dba216d705c3a18d6b35830e488b6c6a4e7cdf0/kiwisolver-1.5.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4432b835675f0ea7414aab3d37d119f7226d24869b7a829caeab49ebda407b0c", size = 1584848, upload-time = "2026-03-09T13:14:19.745Z" }, + { url = "https://files.pythonhosted.org/packages/37/f8/4d4f85cc1870c127c88d950913370dd76138482161cd07eabbc450deff01/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b0feb50971481a2cc44d94e88bdb02cdd497618252ae226b8eb1201b957e368", size = 1391542, upload-time = "2026-03-09T13:14:21.54Z" }, + { url = "https://files.pythonhosted.org/packages/04/0b/65dd2916c84d252b244bd405303220f729e7c17c9d7d33dca6feeff9ffc4/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56fa888f10d0f367155e76ce849fa1166fc9730d13bd2d65a2aa13b6f5424489", size = 1404447, upload-time = "2026-03-09T13:14:23.205Z" }, + { url = "https://files.pythonhosted.org/packages/39/5c/2606a373247babce9b1d056c03a04b65f3cf5290a8eac5d7bdead0a17e21/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:940dda65d5e764406b9fb92761cbf462e4e63f712ab60ed98f70552e496f3bf1", size = 1455918, upload-time = "2026-03-09T13:14:24.74Z" }, + { url = "https://files.pythonhosted.org/packages/d5/d1/c6078b5756670658e9192a2ef11e939c92918833d2745f85cd14a6004bdf/kiwisolver-1.5.0-cp313-cp313t-manylinux_2_39_riscv64.whl", hash = "sha256:89fc958c702ee9a745e4700378f5d23fddbc46ff89e8fdbf5395c24d5c1452a3", size = 1072856, upload-time = "2026-03-09T13:14:26.597Z" }, + { url = "https://files.pythonhosted.org/packages/cb/c8/7def6ddf16eb2b3741d8b172bdaa9af882b03c78e9b0772975408801fa63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9027d773c4ff81487181a925945743413f6069634d0b122d0b37684ccf4f1e18", size = 2333580, upload-time = "2026-03-09T13:14:28.237Z" }, + { url = "https://files.pythonhosted.org/packages/9e/87/2ac1fce0eb1e616fcd3c35caa23e665e9b1948bb984f4764790924594128/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:5b233ea3e165e43e35dba1d2b8ecc21cf070b45b65ae17dd2747d2713d942021", size = 2423018, upload-time = "2026-03-09T13:14:30.018Z" }, + { url = "https://files.pythonhosted.org/packages/67/13/c6700ccc6cc218716bfcda4935e4b2997039869b4ad8a94f364c5a3b8e63/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:ce9bf03dad3b46408c08649c6fbd6ca28a9fce0eb32fdfffa6775a13103b5310", size = 2062804, upload-time = "2026-03-09T13:14:32.888Z" }, + { url = "https://files.pythonhosted.org/packages/1b/bd/877056304626943ff0f1f44c08f584300c199b887cb3176cd7e34f1515f1/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:fc4d3f1fb9ca0ae9f97b095963bc6326f1dbfd3779d6679a1e016b9baaa153d3", size = 2597482, upload-time = "2026-03-09T13:14:34.971Z" }, + { url = "https://files.pythonhosted.org/packages/75/19/c60626c47bf0f8ac5dcf72c6c98e266d714f2fbbfd50cf6dab5ede3aaa50/kiwisolver-1.5.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f443b4825c50a51ee68585522ab4a1d1257fac65896f282b4c6763337ac9f5d2", size = 2394328, upload-time = "2026-03-09T13:14:36.816Z" }, + { url = "https://files.pythonhosted.org/packages/47/84/6a6d5e5bb8273756c27b7d810d47f7ef2f1f9b9fd23c9ee9a3f8c75c9cef/kiwisolver-1.5.0-cp313-cp313t-win_arm64.whl", hash = "sha256:893ff3a711d1b515ba9da14ee090519bad4610ed1962fbe298a434e8c5f8db53", size = 68410, upload-time = "2026-03-09T13:14:38.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/d7/060f45052f2a01ad5762c8fdecd6d7a752b43400dc29ff75cd47225a40fd/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8df31fe574b8b3993cc61764f40941111b25c2d9fea13d3ce24a49907cd2d615", size = 123231, upload-time = "2026-03-09T13:14:41.323Z" }, + { url = "https://files.pythonhosted.org/packages/c2/a7/78da680eadd06ff35edef6ef68a1ad273bad3e2a0936c9a885103230aece/kiwisolver-1.5.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:1d49a49ac4cbfb7c1375301cd1ec90169dfeae55ff84710d782260ce77a75a02", size = 66489, upload-time = "2026-03-09T13:14:42.534Z" }, + { url = "https://files.pythonhosted.org/packages/49/b2/97980f3ad4fae37dd7fe31626e2bf75fbf8bdf5d303950ec1fab39a12da8/kiwisolver-1.5.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0cbe94b69b819209a62cb27bdfa5dc2a8977d8de2f89dfd97ba4f53ed3af754e", size = 64063, upload-time = "2026-03-09T13:14:44.759Z" }, + { url = "https://files.pythonhosted.org/packages/e7/f9/b06c934a6aa8bc91f566bd2a214fd04c30506c2d9e2b6b171953216a65b6/kiwisolver-1.5.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:80aa065ffd378ff784822a6d7c3212f2d5f5e9c3589614b5c228b311fd3063ac", size = 1475913, upload-time = "2026-03-09T13:14:46.247Z" }, + { url = "https://files.pythonhosted.org/packages/6b/f0/f768ae564a710135630672981231320bc403cf9152b5596ec5289de0f106/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e7f886f47ab881692f278ae901039a234e4025a68e6dfab514263a0b1c4ae05", size = 1282782, upload-time = "2026-03-09T13:14:48.458Z" }, + { url = "https://files.pythonhosted.org/packages/e2/9f/1de7aad00697325f05238a5f2eafbd487fb637cc27a558b5367a5f37fb7f/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5060731cc3ed12ca3a8b57acd4aeca5bbc2f49216dd0bec1650a1acd89486bcd", size = 1300815, upload-time = "2026-03-09T13:14:50.721Z" }, + { url = "https://files.pythonhosted.org/packages/5a/c2/297f25141d2e468e0ce7f7a7b92e0cf8918143a0cbd3422c1ad627e85a06/kiwisolver-1.5.0-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a4aa69609f40fce3cbc3f87b2061f042eee32f94b8f11db707b66a26461591a", size = 1347925, upload-time = "2026-03-09T13:14:52.304Z" }, + { url = "https://files.pythonhosted.org/packages/b9/d3/f4c73a02eb41520c47610207b21afa8cdd18fdbf64ffd94674ae21c4812d/kiwisolver-1.5.0-cp314-cp314-manylinux_2_39_riscv64.whl", hash = "sha256:d168fda2dbff7b9b5f38e693182d792a938c31db4dac3a80a4888de603c99554", size = 991322, upload-time = "2026-03-09T13:14:54.637Z" }, + { url = "https://files.pythonhosted.org/packages/7b/46/d3f2efef7732fcda98d22bf4ad5d3d71d545167a852ca710a494f4c15343/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:413b820229730d358efd838ecbab79902fe97094565fdc80ddb6b0a18c18a581", size = 2232857, upload-time = "2026-03-09T13:14:56.471Z" }, + { url = "https://files.pythonhosted.org/packages/3f/ec/2d9756bf2b6d26ae4349b8d3662fb3993f16d80c1f971c179ce862b9dbae/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5124d1ea754509b09e53738ec185584cc609aae4a3b510aaf4ed6aa047ef9303", size = 2329376, upload-time = "2026-03-09T13:14:58.072Z" }, + { url = "https://files.pythonhosted.org/packages/8f/9f/876a0a0f2260f1bde92e002b3019a5fabc35e0939c7d945e0fa66185eb20/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:e4415a8db000bf49a6dd1c478bf70062eaacff0f462b92b0ba68791a905861f9", size = 1982549, upload-time = "2026-03-09T13:14:59.668Z" }, + { url = "https://files.pythonhosted.org/packages/6c/4f/ba3624dfac23a64d54ac4179832860cb537c1b0af06024936e82ca4154a0/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:d618fd27420381a4f6044faa71f46d8bfd911bd077c555f7138ed88729bfbe79", size = 2494680, upload-time = "2026-03-09T13:15:01.364Z" }, + { url = "https://files.pythonhosted.org/packages/39/b7/97716b190ab98911b20d10bf92eca469121ec483b8ce0edd314f51bc85af/kiwisolver-1.5.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5092eb5b1172947f57d6ea7d89b2f29650414e4293c47707eb499ec07a0ac796", size = 2297905, upload-time = "2026-03-09T13:15:03.925Z" }, + { url = "https://files.pythonhosted.org/packages/a3/36/4e551e8aa55c9188bca9abb5096805edbf7431072b76e2298e34fd3a3008/kiwisolver-1.5.0-cp314-cp314-win_amd64.whl", hash = "sha256:d76e2d8c75051d58177e762164d2e9ab92886534e3a12e795f103524f221dd8e", size = 75086, upload-time = "2026-03-09T13:15:07.775Z" }, + { url = "https://files.pythonhosted.org/packages/70/15/9b90f7df0e31a003c71649cf66ef61c3c1b862f48c81007fa2383c8bd8d7/kiwisolver-1.5.0-cp314-cp314-win_arm64.whl", hash = "sha256:fa6248cd194edff41d7ea9425ced8ca3a6f838bfb295f6f1d6e6bb694a8518df", size = 66577, upload-time = "2026-03-09T13:15:09.139Z" }, + { url = "https://files.pythonhosted.org/packages/17/01/7dc8c5443ff42b38e72731643ed7cf1ed9bf01691ae5cdca98501999ed83/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:d1ffeb80b5676463d7a7d56acbe8e37a20ce725570e09549fe738e02ca6b7e1e", size = 125794, upload-time = "2026-03-09T13:15:10.525Z" }, + { url = "https://files.pythonhosted.org/packages/46/8a/b4ebe46ebaac6a303417fab10c2e165c557ddaff558f9699d302b256bc53/kiwisolver-1.5.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:bc4d8e252f532ab46a1de9349e2d27b91fce46736a9eedaa37beaca66f574ed4", size = 67646, upload-time = "2026-03-09T13:15:12.016Z" }, + { url = "https://files.pythonhosted.org/packages/60/35/10a844afc5f19d6f567359bf4789e26661755a2f36200d5d1ed8ad0126e5/kiwisolver-1.5.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6783e069732715ad0c3ce96dbf21dbc2235ab0593f2baf6338101f70371f4028", size = 65511, upload-time = "2026-03-09T13:15:13.311Z" }, + { url = "https://files.pythonhosted.org/packages/f8/8a/685b297052dd041dcebce8e8787b58923b6e78acc6115a0dc9189011c44b/kiwisolver-1.5.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e7c4c09a490dc4d4a7f8cbee56c606a320f9dc28cf92a7157a39d1ce7676a657", size = 1584858, upload-time = "2026-03-09T13:15:15.103Z" }, + { url = "https://files.pythonhosted.org/packages/9e/80/04865e3d4638ac5bddec28908916df4a3075b8c6cc101786a96803188b96/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2a075bd7bd19c70cf67c8badfa36cf7c5d8de3c9ddb8420c51e10d9c50e94920", size = 1392539, upload-time = "2026-03-09T13:15:16.661Z" }, + { url = "https://files.pythonhosted.org/packages/ba/01/77a19cacc0893fa13fafa46d1bba06fb4dc2360b3292baf4b56d8e067b24/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bdd3e53429ff02aa319ba59dfe4ceeec345bf46cf180ec2cf6fd5b942e7975e9", size = 1405310, upload-time = "2026-03-09T13:15:18.229Z" }, + { url = "https://files.pythonhosted.org/packages/53/39/bcaf5d0cca50e604cfa9b4e3ae1d64b50ca1ae5b754122396084599ef903/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cdcb35dc9d807259c981a85531048ede628eabcffb3239adf3d17463518992d", size = 1456244, upload-time = "2026-03-09T13:15:20.444Z" }, + { url = "https://files.pythonhosted.org/packages/d0/7a/72c187abc6975f6978c3e39b7cf67aeb8b3c0a8f9790aa7fd412855e9e1f/kiwisolver-1.5.0-cp314-cp314t-manylinux_2_39_riscv64.whl", hash = "sha256:70d593af6a6ca332d1df73d519fddb5148edb15cd90d5f0155e3746a6d4fcc65", size = 1073154, upload-time = "2026-03-09T13:15:22.039Z" }, + { url = "https://files.pythonhosted.org/packages/c7/ca/cf5b25783ebbd59143b4371ed0c8428a278abe68d6d0104b01865b1bbd0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:377815a8616074cabbf3f53354e1d040c35815a134e01d7614b7692e4bf8acfa", size = 2334377, upload-time = "2026-03-09T13:15:23.741Z" }, + { url = "https://files.pythonhosted.org/packages/4a/e5/b1f492adc516796e88751282276745340e2a72dcd0d36cf7173e0daf3210/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:0255a027391d52944eae1dbb5d4cc5903f57092f3674e8e544cdd2622826b3f0", size = 2425288, upload-time = "2026-03-09T13:15:25.789Z" }, + { url = "https://files.pythonhosted.org/packages/e6/e5/9b21fbe91a61b8f409d74a26498706e97a48008bfcd1864373d32a6ba31c/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:012b1eb16e28718fa782b5e61dc6f2da1f0792ca73bd05d54de6cb9561665fc9", size = 2063158, upload-time = "2026-03-09T13:15:27.63Z" }, + { url = "https://files.pythonhosted.org/packages/b1/02/83f47986138310f95ea95531f851b2a62227c11cbc3e690ae1374fe49f0f/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0e3aafb33aed7479377e5e9a82e9d4bf87063741fc99fc7ae48b0f16e32bdd6f", size = 2597260, upload-time = "2026-03-09T13:15:29.421Z" }, + { url = "https://files.pythonhosted.org/packages/07/18/43a5f24608d8c313dd189cf838c8e68d75b115567c6279de7796197cfb6a/kiwisolver-1.5.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e7a116ae737f0000343218c4edf5bd45893bfeaff0993c0b215d7124c9f77646", size = 2394403, upload-time = "2026-03-09T13:15:31.517Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b5/98222136d839b8afabcaa943b09bd05888c2d36355b7e448550211d1fca4/kiwisolver-1.5.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1dd9b0b119a350976a6d781e7278ec7aca0b201e1a9e2d23d9804afecb6ca681", size = 79687, upload-time = "2026-03-09T13:15:33.204Z" }, + { url = "https://files.pythonhosted.org/packages/99/a2/ca7dc962848040befed12732dff6acae7fb3c4f6fc4272b3f6c9a30b8713/kiwisolver-1.5.0-cp314-cp314t-win_arm64.whl", hash = "sha256:58f812017cd2985c21fbffb4864d59174d4903dd66fa23815e74bbc7a0e2dd57", size = 70032, upload-time = "2026-03-09T13:15:34.411Z" }, + { url = "https://files.pythonhosted.org/packages/1c/fa/2910df836372d8761bb6eff7d8bdcb1613b5c2e03f260efe7abe34d388a7/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_10_13_x86_64.whl", hash = "sha256:5ae8e62c147495b01a0f4765c878e9bfdf843412446a247e28df59936e99e797", size = 130262, upload-time = "2026-03-09T13:15:35.629Z" }, + { url = "https://files.pythonhosted.org/packages/0f/41/c5f71f9f00aabcc71fee8b7475e3f64747282580c2fe748961ba29b18385/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:f6764a4ccab3078db14a632420930f6186058750df066b8ea2a7106df91d3203", size = 138036, upload-time = "2026-03-09T13:15:36.894Z" }, + { url = "https://files.pythonhosted.org/packages/fa/06/7399a607f434119c6e1fdc8ec89a8d51ccccadf3341dee4ead6bd14caaf5/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c31c13da98624f957b0fb1b5bae5383b2333c2c3f6793d9825dd5ce79b525cb7", size = 194295, upload-time = "2026-03-09T13:15:38.22Z" }, + { url = "https://files.pythonhosted.org/packages/b5/91/53255615acd2a1eaca307ede3c90eb550bae9c94581f8c00081b6b1c8f44/kiwisolver-1.5.0-graalpy312-graalpy250_312_native-win_amd64.whl", hash = "sha256:1f1489f769582498610e015a8ef2d36f28f505ab3096d0e16b4858a9ec214f57", size = 75987, upload-time = "2026-03-09T13:15:39.65Z" }, + { url = "https://files.pythonhosted.org/packages/17/6f/6fd4f690a40c2582fa34b97d2678f718acf3706b91d270c65ecb455d0a06/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:295d9ffe712caa9f8a3081de8d32fc60191b4b51c76f02f951fd8407253528f4", size = 59606, upload-time = "2026-03-09T13:15:40.81Z" }, + { url = "https://files.pythonhosted.org/packages/82/a0/2355d5e3b338f13ce63f361abb181e3b6ea5fffdb73f739b3e80efa76159/kiwisolver-1.5.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:51e8c4084897de9f05898c2c2a39af6318044ae969d46ff7a34ed3f96274adca", size = 57537, upload-time = "2026-03-09T13:15:42.071Z" }, + { url = "https://files.pythonhosted.org/packages/c8/b9/1d50e610ecadebe205b71d6728fd224ce0e0ca6aba7b9cbe1da049203ac5/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b83af57bdddef03c01a9138034c6ff03181a3028d9a1003b301eb1a55e161a3f", size = 79888, upload-time = "2026-03-09T13:15:43.317Z" }, + { url = "https://files.pythonhosted.org/packages/cd/ee/b85ffcd75afed0357d74f0e6fc02a4507da441165de1ca4760b9f496390d/kiwisolver-1.5.0-pp310-pypy310_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf4679a3d71012a7c2bf360e5cd878fbd5e4fcac0896b56393dec239d81529ed", size = 77584, upload-time = "2026-03-09T13:15:44.605Z" }, + { url = "https://files.pythonhosted.org/packages/6b/dd/644d0dde6010a8583b4cd66dd41c5f83f5325464d15c4f490b3340ab73b4/kiwisolver-1.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:41024ed50e44ab1a60d3fe0a9d15a4ccc9f5f2b1d814ff283c8d01134d5b81bc", size = 73390, upload-time = "2026-03-09T13:15:45.832Z" }, + { url = "https://files.pythonhosted.org/packages/e9/eb/5fcbbbf9a0e2c3a35effb88831a483345326bbc3a030a3b5b69aee647f84/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ec4c85dc4b687c7f7f15f553ff26a98bfe8c58f5f7f0ac8905f0ba4c7be60232", size = 59532, upload-time = "2026-03-09T13:15:47.047Z" }, + { url = "https://files.pythonhosted.org/packages/c3/9b/e17104555bb4db148fd52327feea1e96be4b88e8e008b029002c281a21ab/kiwisolver-1.5.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:12e91c215a96e39f57989c8912ae761286ac5a9584d04030ceb3368a357f017a", size = 57420, upload-time = "2026-03-09T13:15:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/48/44/2b5b95b7aa39fb2d8d9d956e0f3d5d45aef2ae1d942d4c3ffac2f9cfed1a/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:be4a51a55833dc29ab5d7503e7bcb3b3af3402d266018137127450005cdfe737", size = 79892, upload-time = "2026-03-09T13:15:49.694Z" }, + { url = "https://files.pythonhosted.org/packages/52/7d/7157f9bba6b455cfb4632ed411e199fc8b8977642c2b12082e1bd9e6d173/kiwisolver-1.5.0-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:daae526907e262de627d8f70058a0f64acc9e2641c164c99c8f594b34a799a16", size = 77603, upload-time = "2026-03-09T13:15:50.945Z" }, + { url = "https://files.pythonhosted.org/packages/0a/dd/8050c947d435c8d4bc94e3252f4d8bb8a76cfb424f043a8680be637a57f1/kiwisolver-1.5.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:59cd8683f575d96df5bb48f6add94afc055012c29e28124fcae2b63661b9efb1", size = 73558, upload-time = "2026-03-09T13:15:52.112Z" }, +] + +[[package]] +name = "lefthook" +version = "2.1.6" +source = { registry = "https://pypi.org/simple" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/5a/1c/95addeea6b681f02cd44e40d8ce970973783f7b48081af88d3831c4f6da6/lefthook-2.1.6-py3-none-macosx_10_15_x86_64.whl", hash = "sha256:6d4608d0bb9dbcf10d333132973941c21bc7cde31a328658611e2066eec26d7e", size = 5439518, upload-time = "2026-04-16T07:34:18.136Z" }, + { url = "https://files.pythonhosted.org/packages/cd/d4/2c645051bed898f1ad377e7c2e611e0f857502ca76d052db0f8333bb668d/lefthook-2.1.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fa6395917dc510c2622f31b6d3992c5506ff2a7569cd9d321712ec29689229b3", size = 4964898, upload-time = "2026-04-16T07:34:13.497Z" }, + { url = "https://files.pythonhosted.org/packages/19/ea/15b0384c1227ad172af0c18f21f7e00c570ccce086af471ac32edc2cb507/lefthook-2.1.6-py3-none-manylinux_2_17_aarch64.whl", hash = "sha256:016295036dd1d94af7ea6604247f0c47102559fb12f97ffcfe7880e8d1ce7a1f", size = 4791370, upload-time = "2026-04-16T07:34:15.04Z" }, + { url = "https://files.pythonhosted.org/packages/aa/c0/3d43c9e1a08fa79d53f0c6eb808fb0ae9becf29bc7bd89cd757470af040e/lefthook-2.1.6-py3-none-manylinux_2_17_x86_64.whl", hash = "sha256:6c00cd91d553e064a2f71c35d2497b4350d1efdf18dd8f2c7ce2b1d6e8e2e147", size = 5367784, upload-time = "2026-04-16T07:34:10.414Z" }, + { url = "https://files.pythonhosted.org/packages/e6/99/cad1e694989964a8a79b34fdd18e6642bc631e280c06a9341565b5861e3b/lefthook-2.1.6-py3-none-win_amd64.whl", hash = "sha256:e571c48a227f51e5b8aec117c550c6d2ad1f74034e87afd5b0c98cbef319ad3e", size = 5516604, upload-time = "2026-04-16T07:34:12.061Z" }, + { url = "https://files.pythonhosted.org/packages/85/e9/286657a2c7efbb8701380c4c8a08c54d7f58938a4610d660c463fa074ee3/lefthook-2.1.6-py3-none-win_arm64.whl", hash = "sha256:985b88d908067a6d48a0e89cbc20c18b6a68a3fc4d44387f8ac1c39b85f0f18b", size = 4867769, upload-time = "2026-04-16T07:34:16.757Z" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.9" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "contourpy", version = "1.3.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "contourpy", version = "1.3.3", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/6f/340b04986e67aac6f66c5145ce68bf72c64bed30f92c8913499a6e6b8f99/matplotlib-3.10.9-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:77210dce9cb8153dffc967efaae990543392563d5a376d4dd8539bebcb0ed217", size = 8296625, upload-time = "2026-04-24T00:11:43.376Z" }, + { url = "https://files.pythonhosted.org/packages/bb/2f/127081eb83162053ebb9678ceac64220b93a663e0167432566e9c7c82aab/matplotlib-3.10.9-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1e7698ac9868428e84d2c967424803b2472ff7167d9d6590d4204ed775343c3b", size = 8188790, upload-time = "2026-04-24T00:11:46.556Z" }, + { url = "https://files.pythonhosted.org/packages/fc/b7/d8bcec2626c35f96972bff656299fef4578113ea6193c8fdad324710410c/matplotlib-3.10.9-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1aa972116abb4c9d201bf245620b433726cb6856f3bef6a78f776a00f5c92d37", size = 8769389, upload-time = "2026-04-24T00:11:48.959Z" }, + { url = "https://files.pythonhosted.org/packages/12/49/b78e214a527ea732033b7f4d37f7afb504d74ba9d134bd47938230dfb8b1/matplotlib-3.10.9-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2f11957b27ce53497dd4d7b235c4d4f1faf383dfb39d0c5beb833bff883294", size = 9589657, upload-time = "2026-04-24T00:11:51.915Z" }, + { url = "https://files.pythonhosted.org/packages/5f/15/5246f7b43beae19c74dfee651d58d6cc8112e06f77adb4e88cc04f2e3a23/matplotlib-3.10.9-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b049278ddce116aaa1c1377ebf58adea909132dfce0281cf7e3a1ea9fc2e2c65", size = 9651983, upload-time = "2026-04-24T00:11:54.766Z" }, + { url = "https://files.pythonhosted.org/packages/75/77/5acecfe672ba0fa1b8c0454f69ce155d1e6fc5852fa7206bf9afaf767121/matplotlib-3.10.9-cp310-cp310-win_amd64.whl", hash = "sha256:82834c3c292d24d3a8aae77cd2d20019de69d692a34a970e4fdb8d33e2ea3dda", size = 8199701, upload-time = "2026-04-24T00:11:58.389Z" }, + { url = "https://files.pythonhosted.org/packages/4c/8c/290f021104741fea63769c31494f5324c0cd249bf536a65a4350767b1f22/matplotlib-3.10.9-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:68cfdcede415f7c8f5577b03303dd94526cdb6d11036cecdc205e08733b2d2bb", size = 8306860, upload-time = "2026-04-24T00:12:01.207Z" }, + { url = "https://files.pythonhosted.org/packages/51/18/325cd32ece1120d1da51cc4e4294c6580190699490183fc2fe8cb6d61ec5/matplotlib-3.10.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfca0129678bd56379db26c52b5d77ed7de314c047492fbdc763aa7501710cfb", size = 8199254, upload-time = "2026-04-24T00:12:04.239Z" }, + { url = "https://files.pythonhosted.org/packages/79/db/e28c1b83e3680740aa78925f5fb2ae4d16207207419ad75ea9fe604f8676/matplotlib-3.10.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8e436d155fa8a3399dc62683f8f5d0e2e50d25d0144a73edd73f82eec8f4abfb", size = 8777092, upload-time = "2026-04-24T00:12:06.793Z" }, + { url = "https://files.pythonhosted.org/packages/55/fa/3ce7adfe9ba101748f465211660d9c6374c876b671bdb8c2bb6d347e8b94/matplotlib-3.10.9-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56fc0bd271b00025c6edfdc7c2dcd247372c8e1544971d62e1dc7c17367e8bf9", size = 9595691, upload-time = "2026-04-24T00:12:09.706Z" }, + { url = "https://files.pythonhosted.org/packages/36/c4/6960a76686ed668f2c60f84e9799ba4c0d56abdb36b1577b60c1d061d1ec/matplotlib-3.10.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a5a6104ed666402ba5106d7f36e0e0cdca4e8d7fa4d39708ca88019e2835a2eb", size = 9659771, upload-time = "2026-04-24T00:12:12.766Z" }, + { url = "https://files.pythonhosted.org/packages/7e/0d/271aace3342157c64700c9ff4c59c7b392f3dbab393692e8db6fbe7ab96c/matplotlib-3.10.9-cp311-cp311-win_amd64.whl", hash = "sha256:d730e984eddf56974c3e72b6129c7ca462ac38dc624338f4b0b23eb23ecba00f", size = 8205112, upload-time = "2026-04-24T00:12:15.773Z" }, + { url = "https://files.pythonhosted.org/packages/e2/ee/cb57ad4754f3e7b9174ce6ce66d9205fb827067e48a9f58ac09d7e7d6b77/matplotlib-3.10.9-cp311-cp311-win_arm64.whl", hash = "sha256:51bf0ddbdc598e060d46c16b5590708f81a1624cefbaaf62f6a81bf9285b8c80", size = 8132310, upload-time = "2026-04-24T00:12:18.645Z" }, + { url = "https://files.pythonhosted.org/packages/35/c6/5581e26c72233ebb2a2a6fed2d24fb7c66b4700120b813f51b0555acf0b6/matplotlib-3.10.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f0c3c28d9fbcc1fe7a03be236d73430cf6409c41fb2383a7ac52fe932b072cb1", size = 8319908, upload-time = "2026-04-24T00:12:21.323Z" }, + { url = "https://files.pythonhosted.org/packages/b7/18/4880dd762e40cd360c1bf06e890c5a97b997e91cb324602b1a19950ad5ce/matplotlib-3.10.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:41cb28c2bd769aa3e98322c6ab09854cbcc52ab69d2759d681bba3e327b2b320", size = 8216016, upload-time = "2026-04-24T00:12:23.4Z" }, + { url = "https://files.pythonhosted.org/packages/32/91/d024616abdba99e83120e07a20658976f6a343646710760c4a51df126029/matplotlib-3.10.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ae20801130378b82d647ff5047c07316295b68dc054ca6b3c13519d0ea624285", size = 8789336, upload-time = "2026-04-24T00:12:26.096Z" }, + { url = "https://files.pythonhosted.org/packages/5c/04/030a2f61ef2158f5e4c259487a92ac877732499fb33d871585d89e03c42d/matplotlib-3.10.9-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c63ebcd8b4b169eb2f5c200552ae6b8be8999a005b6b507ed76fb8d7d674fe2", size = 9604602, upload-time = "2026-04-24T00:12:29.052Z" }, + { url = "https://files.pythonhosted.org/packages/fc/c2/541e4d09d87bb6b5830fc28b4c887a9a8cf4e1c6cee698a8c05552ae2003/matplotlib-3.10.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d75d11c949914165976c621b2324f9ef162af7ebf4b057ddf95dd1dba7e5edcf", size = 9670966, upload-time = "2026-04-24T00:12:32.131Z" }, + { url = "https://files.pythonhosted.org/packages/04/a1/4571fc46e7702de8d0c2dc54ad1b2f8e29328dea3ee90831181f7353d93c/matplotlib-3.10.9-cp312-cp312-win_amd64.whl", hash = "sha256:d091f9d758b34aaaaa6331d13574bf01891d903b3dec59bfff458ef7551de5d6", size = 8217462, upload-time = "2026-04-24T00:12:35.226Z" }, + { url = "https://files.pythonhosted.org/packages/4b/d0/2269edb12aa30c13c8bcc9382892e39943ce1d28aab4ec296e0381798e81/matplotlib-3.10.9-cp312-cp312-win_arm64.whl", hash = "sha256:10cc5ce06d10231c36f40e875f3c7e8050362a4ee8f0ee5d29a6b3277d57bb42", size = 8136688, upload-time = "2026-04-24T00:12:37.442Z" }, + { url = "https://files.pythonhosted.org/packages/aa/d3/8d4f6afbecb49fc04e060a57c0fce39ea51cc163a6bd87303ccd698e4fa6/matplotlib-3.10.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b580440f1ff81a0e34122051a3dfabb7e4b7f9e380629929bde0eff9af72165f", size = 8320331, upload-time = "2026-04-24T00:12:39.688Z" }, + { url = "https://files.pythonhosted.org/packages/63/d9/9e14bc7564bf92d5ffa801ae5fac819ce74b925dfb55e3ebde61a3bbad3e/matplotlib-3.10.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:b1b745c489cd1a77a0dc1120a05dc87af9798faebc913601feb8c73d89bf2d1e", size = 8216461, upload-time = "2026-04-24T00:12:42.494Z" }, + { url = "https://files.pythonhosted.org/packages/8a/17/4402d0d14ccf1dfc70932600b68097fbbf9c898a4871d2cbbe79c7801a32/matplotlib-3.10.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8f3bcac1ca5ed000a6f4337d47ba67dfddf37ed6a46c15fd7f014997f7bf865f", size = 8790091, upload-time = "2026-04-24T00:12:44.789Z" }, + { url = "https://files.pythonhosted.org/packages/3e/0b/322aeec06dd9b91411f92028b37d447342770a24392aa4813e317064dad5/matplotlib-3.10.9-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a8d66a55def891c33147ba3ba9bfcabf0b526a43764c818acbb4525e5ed0838", size = 9605027, upload-time = "2026-04-24T00:12:47.583Z" }, + { url = "https://files.pythonhosted.org/packages/74/88/5f13482f55e7b00bcfc09838b093c2456e1379978d2a146844aae05350ad/matplotlib-3.10.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d843374407c4017a6403b59c6c81606773d136f3259d5b6da3131bc814542cc2", size = 9671269, upload-time = "2026-04-24T00:12:50.878Z" }, + { url = "https://files.pythonhosted.org/packages/c5/e0/0840fd2f93da988ec660b8ad1984abe9f25d2aed22a5e394ff1c68c88307/matplotlib-3.10.9-cp313-cp313-win_amd64.whl", hash = "sha256:f4399f64b3e94cd500195490972ae1ee81170df1636fa15364d157d5bdd7b921", size = 8217588, upload-time = "2026-04-24T00:12:53.784Z" }, + { url = "https://files.pythonhosted.org/packages/47/b9/d706d06dd605c49b9f83a2aed8c13e3e5db70697d7a80b7e3d7915de6b17/matplotlib-3.10.9-cp313-cp313-win_arm64.whl", hash = "sha256:ba7b3b8ef09eab7df0e86e9ae086faa433efbfbdb46afcb3aa16aabf779469a8", size = 8136913, upload-time = "2026-04-24T00:12:56.501Z" }, + { url = "https://files.pythonhosted.org/packages/9b/45/6e32d96978264c8ca8c4b1010adb955a1a49cfaf314e212bbc8908f04a61/matplotlib-3.10.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:09218df8a93712bd6ea133e83a153c755448cf7868316c531cffcc43f69d1cc9", size = 8368019, upload-time = "2026-04-24T00:12:58.896Z" }, + { url = "https://files.pythonhosted.org/packages/86/0a/c8e3d3bba245f0f7fc424937f8ff7ef77291a36af3edb97ccd78aa93d84f/matplotlib-3.10.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:82368699727bfb7b0182e1aa13082e3c08e092fa1a25d3e1fd92405bff96f6d4", size = 8264645, upload-time = "2026-04-24T00:13:01.406Z" }, + { url = "https://files.pythonhosted.org/packages/3d/aa/5bf5a14fe4fed73a4209a155606f8096ff797aad89c6c35179026571133e/matplotlib-3.10.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3225f4e1edcb8c86c884ddf79ebe20ecd0a67d30188f279897554ccd8fded4dc", size = 8802194, upload-time = "2026-04-24T00:13:03.702Z" }, + { url = "https://files.pythonhosted.org/packages/dd/5e/b4be852d6bba6fd15893fadf91ff26ae49cb91aac789e95dde9d342e664f/matplotlib-3.10.9-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de2445a0c6690d21b7eb6ce071cebad6d40a2e9bdf10d039074a96ba19797b99", size = 9622684, upload-time = "2026-04-24T00:13:06.647Z" }, + { url = "https://files.pythonhosted.org/packages/4c/3d/ed428c971139112ef730f62770654d609467346d09d4b62617e1afd68a5a/matplotlib-3.10.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:b2b9516251cb89ff618d757daec0e2ed1bf21248013844a853d87ef85ab3081d", size = 9680790, upload-time = "2026-04-24T00:13:10.009Z" }, + { url = "https://files.pythonhosted.org/packages/e7/09/052e884aaf2b985c63cb79f715f1d5b6a3eaa7de78f6a52b9dbc077d5b53/matplotlib-3.10.9-cp313-cp313t-win_amd64.whl", hash = "sha256:e9fae004b941b23ff2edcf1567a857ed77bafc8086ffa258190462328434faf8", size = 8287571, upload-time = "2026-04-24T00:13:13.087Z" }, + { url = "https://files.pythonhosted.org/packages/f4/38/ae27288e788c35a4250491422f3db7750366fc8c97d6f36fbdecfc1f5518/matplotlib-3.10.9-cp313-cp313t-win_arm64.whl", hash = "sha256:6b63d9c7c769b88ab81e10dc86e4e0607cf56817b9f9e6cf24b2a5f1693b8e38", size = 8188292, upload-time = "2026-04-24T00:13:15.546Z" }, + { url = "https://files.pythonhosted.org/packages/d6/e6/3bd8afd04949f02eabc1c17115ea5255e19cacd4d06fc5abdde4eeb0052c/matplotlib-3.10.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:172db52c9e683f5d12eaf57f0f54834190e12581fe1cc2a19595a8f5acb4e77d", size = 8321276, upload-time = "2026-04-24T00:13:18.318Z" }, + { url = "https://files.pythonhosted.org/packages/41/86/86231232fff41c9f8e4a1a7d7a597d349a02527109c3af7d618366122139/matplotlib-3.10.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:97e35e8d39ccc85859095e01a53847432ba9a53ddf7986f7a54a11b73d0e143f", size = 8218218, upload-time = "2026-04-24T00:13:20.974Z" }, + { url = "https://files.pythonhosted.org/packages/85/8f/becc9722cafc64f5d2eb0b7c1bf5f585271c618a45dbd8fabeb021f898b6/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aba1615dabe83188e19d4f75a253c6a08423e04c1425e64039f800050a69de6b", size = 9608145, upload-time = "2026-04-24T00:13:23.228Z" }, + { url = "https://files.pythonhosted.org/packages/32/5d/f7e914f7d9325abff4057cee62c0fa70263683189f774473cbfb534cd13b/matplotlib-3.10.9-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34cf8167e023ad956c15f36302911d5406bd99a9862c1a8499ea6f7c0e015dc2", size = 9885085, upload-time = "2026-04-24T00:13:25.849Z" }, + { url = "https://files.pythonhosted.org/packages/a5/fd/fa69f2221534e80cc5772ac2b7d222011a2acafc2ec7216d5dd174c864ae/matplotlib-3.10.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:59476c6d29d612b8e9bb6ce8c5b631be6ba8f9e3a2421f22a02b192c7dd28716", size = 9672358, upload-time = "2026-04-24T00:13:28.906Z" }, + { url = "https://files.pythonhosted.org/packages/ab/1a/5a4f747a8b271cbb024946d2dd3c913ab5032ba430626f8c3528ada96b4b/matplotlib-3.10.9-cp314-cp314-win_amd64.whl", hash = "sha256:336b9acc64d309063126edcdaca00db9373af3c476bb94388fe9c5a53ad13e6f", size = 8349970, upload-time = "2026-04-24T00:13:31.904Z" }, + { url = "https://files.pythonhosted.org/packages/64/dc/95d60ecaefe30680a154b52ea96ab4b0dab547f1fd6aa12f5fb655e89cae/matplotlib-3.10.9-cp314-cp314-win_arm64.whl", hash = "sha256:2dc9477819ffd78ad12a20df1d9d6a6bd4fec6aaa9072681465fddca052f1456", size = 8272785, upload-time = "2026-04-24T00:13:34.511Z" }, + { url = "https://files.pythonhosted.org/packages/70/a0/005d68bc8b8418300ce6591f18586910a8526806e2ab663933d9f20a41e9/matplotlib-3.10.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:da4e09638420548f31c354032a6250e473c68e5a4e96899b4844cf39ddea23fe", size = 8367999, upload-time = "2026-04-24T00:13:36.962Z" }, + { url = "https://files.pythonhosted.org/packages/22/05/1236cc9290be70b2498af20ca348add76e3fffe7f67b477db5133a84f3ea/matplotlib-3.10.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:345f6f68ecc8da0ca56fad2ea08fde1a115eda530079eca185d50a7bc3e146c6", size = 8264543, upload-time = "2026-04-24T00:13:39.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/c2/071f5a5ff6c5bd63aaaf2f45c811d9bf2ced94bde188d9e1a519e21d0cba/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4edcfbd8565339aa62f1cd4012f7180926fdbe71850f7b0d3c379c175cd6b66c", size = 9622800, upload-time = "2026-04-24T00:13:42.296Z" }, + { url = "https://files.pythonhosted.org/packages/95/57/da7d1f10a85624b9e7db68e069dd94e58dc41dbf9463c5921632ecbe3661/matplotlib-3.10.9-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6be157fe17fc37cb95ac1d7374cf717ce9259616edec911a78d9d26dae8522d4", size = 9888561, upload-time = "2026-04-24T00:13:45.026Z" }, + { url = "https://files.pythonhosted.org/packages/67/b2/ef8d6bb59b0edb6c16c968b70f548aa13b54348972def5aa6ac85df67145/matplotlib-3.10.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:4e42042d54db34fda4e95a7bd3e5789c2a995d2dad3eb8850232ee534092fbbf", size = 9680884, upload-time = "2026-04-24T00:13:48.066Z" }, + { url = "https://files.pythonhosted.org/packages/61/1c/d21bfeb9931881ebe96bcfcff27c7ae4b160ae0ec291a714c42641a56d75/matplotlib-3.10.9-cp314-cp314t-win_amd64.whl", hash = "sha256:c27df8b3848f32a83d1767566595e43cfaa4460380974da06f4279a7ec143c39", size = 8432333, upload-time = "2026-04-24T00:13:51.008Z" }, + { url = "https://files.pythonhosted.org/packages/78/23/92493c3e6e1b635ccfff146f7b99e674808787915420373ac399283764c2/matplotlib-3.10.9-cp314-cp314t-win_arm64.whl", hash = "sha256:a49f1eadc84ca85fd72fa4e89e70e61bf86452df6f971af04b12c60761a0772c", size = 8324785, upload-time = "2026-04-24T00:13:53.633Z" }, + { url = "https://files.pythonhosted.org/packages/2c/2b/0e92ad0ac446633f928a1563db4aa8add407e1924faf0ded5b95b35afb27/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1872fb212a05b729e649754a72d5da61d03e0554d76e80303b6f83d1d2c0552b", size = 8293058, upload-time = "2026-04-24T00:13:56.339Z" }, + { url = "https://files.pythonhosted.org/packages/4b/23/74682fd369f5299ceda438fea2a0662e6383b85c9383fb9cdfcf04713e07/matplotlib-3.10.9-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:985f2238880e2e69093f588f5fe2e46771747febf0649f3cf7f7b7480875317f", size = 8186627, upload-time = "2026-04-24T00:13:58.623Z" }, + { url = "https://files.pythonhosted.org/packages/ca/e8/368aab88f3c4cd8992800f31abfe0670c3e47540ba20a97e9fdbcde594b3/matplotlib-3.10.9-pp310-pypy310_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6640f75af2c6148293caa0a2b39dd806a492dd66c8a8b04035813e33d0fd2585", size = 8764117, upload-time = "2026-04-24T00:14:01.684Z" }, + { url = "https://files.pythonhosted.org/packages/63/e2/9f66ca6a651a52abfe0d4964ce01439ed34f3f1e119de10ff3a07f403043/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:42fb814efabe95c06c1994d8ab5a8385f43a249e23badd3ba931d4308e5bca20", size = 8304420, upload-time = "2026-04-24T00:14:04.57Z" }, + { url = "https://files.pythonhosted.org/packages/e8/e8/467c03568218792906aa87b5e7bb379b605e056ed0c74fe00c051786d925/matplotlib-3.10.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f76e640a5268850bfda54b5131b1b1941cc685e42c5fa98ed9f2d64038308cba", size = 8197981, upload-time = "2026-04-24T00:14:07.233Z" }, + { url = "https://files.pythonhosted.org/packages/6f/87/afead29192170917537934c6aff4b008c805fff7b1ccea0c79120d96beda/matplotlib-3.10.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3fc0364dfbe1d07f6d15c5ebd0c5bf89e126916e5a8667dd4a7a6e84c36653d4", size = 8774002, upload-time = "2026-04-24T00:14:09.816Z" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.1" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/c7/74/97e72a36efd4ae2bccb3463284300f8953f199b5ffbc04cbbb0ec78f74b1/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe", size = 8110, upload-time = "2025-10-23T09:00:22.126Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/af/33/ee4519fa02ed11a94aef9559552f3b17bb863f2ecfe1a35dc7f548cde231/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76", size = 9516, upload-time = "2025-10-23T09:00:20.675Z" }, +] + +[[package]] +name = "mazelib" +version = "0.9.16" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cython" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +wheels = [ + { url = "https://files.pythonhosted.org/packages/cb/d5/d29473f861741768da3cac196f8a9b8452e3064f528eb8c9c13cf55ef847/mazelib-0.9.16-py2.py3-none-any.whl", hash = "sha256:2a2fde8559d140b5bef52b298d3d6319f7dfab4b3a16bf7fc7abc9e6cda52a04", size = 46181, upload-time = "2024-11-16T21:19:44.837Z" }, +] + +[[package]] +name = "mccabe" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e7/ff/0ffefdcac38932a54d2b5eed4e0ba8a408f215002cd178ad1df0f2806ff8/mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325", size = 9658, upload-time = "2022-01-24T01:14:51.113Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/27/1a/1f68f9ba0c207934b35b86a8ca3aad8395a3d6dd7921c0686e23853ff5a9/mccabe-0.7.0-py2.py3-none-any.whl", hash = "sha256:6c2d30ab6be0e4a46919781807b4f0d834ebdd6c6e3dca0bda5a15f863427b6e", size = 7350, upload-time = "2022-01-24T01:14:49.62Z" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/83/f8/51569ac65d696c8ecbee95938f89d4abf00f47d58d48f6fbabfe8f0baefe/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe", size = 7418, upload-time = "2024-01-21T14:25:19.227Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/a0/c4/c2971a3ba4c6103a3d10c4b0f24f461ddc027f0f09763220cf35ca1401b3/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c", size = 5195, upload-time = "2024-01-21T14:25:17.223Z" }, +] + +[[package]] +name = "numpy" +version = "2.2.6" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version < '3.11'", +] +sdist = { url = "https://files.pythonhosted.org/packages/76/21/7d2a95e4bba9dc13d043ee156a356c0a8f0c6309dff6b21b4d71a073b8a8/numpy-2.2.6.tar.gz", hash = "sha256:e29554e2bef54a90aa5cc07da6ce955accb83f21ab5de01a62c8478897b264fd", size = 20276440, upload-time = "2025-05-17T22:38:04.611Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9a/3e/ed6db5be21ce87955c0cbd3009f2803f59fa08df21b5df06862e2d8e2bdd/numpy-2.2.6-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b412caa66f72040e6d268491a59f2c43bf03eb6c96dd8f0307829feb7fa2b6fb", size = 21165245, upload-time = "2025-05-17T21:27:58.555Z" }, + { url = "https://files.pythonhosted.org/packages/22/c2/4b9221495b2a132cc9d2eb862e21d42a009f5a60e45fc44b00118c174bff/numpy-2.2.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8e41fd67c52b86603a91c1a505ebaef50b3314de0213461c7a6e99c9a3beff90", size = 14360048, upload-time = "2025-05-17T21:28:21.406Z" }, + { url = "https://files.pythonhosted.org/packages/fd/77/dc2fcfc66943c6410e2bf598062f5959372735ffda175b39906d54f02349/numpy-2.2.6-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:37e990a01ae6ec7fe7fa1c26c55ecb672dd98b19c3d0e1d1f326fa13cb38d163", size = 5340542, upload-time = "2025-05-17T21:28:30.931Z" }, + { url = "https://files.pythonhosted.org/packages/7a/4f/1cb5fdc353a5f5cc7feb692db9b8ec2c3d6405453f982435efc52561df58/numpy-2.2.6-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:5a6429d4be8ca66d889b7cf70f536a397dc45ba6faeb5f8c5427935d9592e9cf", size = 6878301, upload-time = "2025-05-17T21:28:41.613Z" }, + { url = "https://files.pythonhosted.org/packages/eb/17/96a3acd228cec142fcb8723bd3cc39c2a474f7dcf0a5d16731980bcafa95/numpy-2.2.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:efd28d4e9cd7d7a8d39074a4d44c63eda73401580c5c76acda2ce969e0a38e83", size = 14297320, upload-time = "2025-05-17T21:29:02.78Z" }, + { url = "https://files.pythonhosted.org/packages/b4/63/3de6a34ad7ad6646ac7d2f55ebc6ad439dbbf9c4370017c50cf403fb19b5/numpy-2.2.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc7b73d02efb0e18c000e9ad8b83480dfcd5dfd11065997ed4c6747470ae8915", size = 16801050, upload-time = "2025-05-17T21:29:27.675Z" }, + { url = "https://files.pythonhosted.org/packages/07/b6/89d837eddef52b3d0cec5c6ba0456c1bf1b9ef6a6672fc2b7873c3ec4e2e/numpy-2.2.6-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:74d4531beb257d2c3f4b261bfb0fc09e0f9ebb8842d82a7b4209415896adc680", size = 15807034, upload-time = "2025-05-17T21:29:51.102Z" }, + { url = "https://files.pythonhosted.org/packages/01/c8/dc6ae86e3c61cfec1f178e5c9f7858584049b6093f843bca541f94120920/numpy-2.2.6-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:8fc377d995680230e83241d8a96def29f204b5782f371c532579b4f20607a289", size = 18614185, upload-time = "2025-05-17T21:30:18.703Z" }, + { url = "https://files.pythonhosted.org/packages/5b/c5/0064b1b7e7c89137b471ccec1fd2282fceaae0ab3a9550f2568782d80357/numpy-2.2.6-cp310-cp310-win32.whl", hash = "sha256:b093dd74e50a8cba3e873868d9e93a85b78e0daf2e98c6797566ad8044e8363d", size = 6527149, upload-time = "2025-05-17T21:30:29.788Z" }, + { url = "https://files.pythonhosted.org/packages/a3/dd/4b822569d6b96c39d1215dbae0582fd99954dcbcf0c1a13c61783feaca3f/numpy-2.2.6-cp310-cp310-win_amd64.whl", hash = "sha256:f0fd6321b839904e15c46e0d257fdd101dd7f530fe03fd6359c1ea63738703f3", size = 12904620, upload-time = "2025-05-17T21:30:48.994Z" }, + { url = "https://files.pythonhosted.org/packages/da/a8/4f83e2aa666a9fbf56d6118faaaf5f1974d456b1823fda0a176eff722839/numpy-2.2.6-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f9f1adb22318e121c5c69a09142811a201ef17ab257a1e66ca3025065b7f53ae", size = 21176963, upload-time = "2025-05-17T21:31:19.36Z" }, + { url = "https://files.pythonhosted.org/packages/b3/2b/64e1affc7972decb74c9e29e5649fac940514910960ba25cd9af4488b66c/numpy-2.2.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c820a93b0255bc360f53eca31a0e676fd1101f673dda8da93454a12e23fc5f7a", size = 14406743, upload-time = "2025-05-17T21:31:41.087Z" }, + { url = "https://files.pythonhosted.org/packages/4a/9f/0121e375000b5e50ffdd8b25bf78d8e1a5aa4cca3f185d41265198c7b834/numpy-2.2.6-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:3d70692235e759f260c3d837193090014aebdf026dfd167834bcba43e30c2a42", size = 5352616, upload-time = "2025-05-17T21:31:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/31/0d/b48c405c91693635fbe2dcd7bc84a33a602add5f63286e024d3b6741411c/numpy-2.2.6-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:481b49095335f8eed42e39e8041327c05b0f6f4780488f61286ed3c01368d491", size = 6889579, upload-time = "2025-05-17T21:32:01.712Z" }, + { url = "https://files.pythonhosted.org/packages/52/b8/7f0554d49b565d0171eab6e99001846882000883998e7b7d9f0d98b1f934/numpy-2.2.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b64d8d4d17135e00c8e346e0a738deb17e754230d7e0810ac5012750bbd85a5a", size = 14312005, upload-time = "2025-05-17T21:32:23.332Z" }, + { url = "https://files.pythonhosted.org/packages/b3/dd/2238b898e51bd6d389b7389ffb20d7f4c10066d80351187ec8e303a5a475/numpy-2.2.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba10f8411898fc418a521833e014a77d3ca01c15b0c6cdcce6a0d2897e6dbbdf", size = 16821570, upload-time = "2025-05-17T21:32:47.991Z" }, + { url = "https://files.pythonhosted.org/packages/83/6c/44d0325722cf644f191042bf47eedad61c1e6df2432ed65cbe28509d404e/numpy-2.2.6-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bd48227a919f1bafbdda0583705e547892342c26fb127219d60a5c36882609d1", size = 15818548, upload-time = "2025-05-17T21:33:11.728Z" }, + { url = "https://files.pythonhosted.org/packages/ae/9d/81e8216030ce66be25279098789b665d49ff19eef08bfa8cb96d4957f422/numpy-2.2.6-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9551a499bf125c1d4f9e250377c1ee2eddd02e01eac6644c080162c0c51778ab", size = 18620521, upload-time = "2025-05-17T21:33:39.139Z" }, + { url = "https://files.pythonhosted.org/packages/6a/fd/e19617b9530b031db51b0926eed5345ce8ddc669bb3bc0044b23e275ebe8/numpy-2.2.6-cp311-cp311-win32.whl", hash = "sha256:0678000bb9ac1475cd454c6b8c799206af8107e310843532b04d49649c717a47", size = 6525866, upload-time = "2025-05-17T21:33:50.273Z" }, + { url = "https://files.pythonhosted.org/packages/31/0a/f354fb7176b81747d870f7991dc763e157a934c717b67b58456bc63da3df/numpy-2.2.6-cp311-cp311-win_amd64.whl", hash = "sha256:e8213002e427c69c45a52bbd94163084025f533a55a59d6f9c5b820774ef3303", size = 12907455, upload-time = "2025-05-17T21:34:09.135Z" }, + { url = "https://files.pythonhosted.org/packages/82/5d/c00588b6cf18e1da539b45d3598d3557084990dcc4331960c15ee776ee41/numpy-2.2.6-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41c5a21f4a04fa86436124d388f6ed60a9343a6f767fced1a8a71c3fbca038ff", size = 20875348, upload-time = "2025-05-17T21:34:39.648Z" }, + { url = "https://files.pythonhosted.org/packages/66/ee/560deadcdde6c2f90200450d5938f63a34b37e27ebff162810f716f6a230/numpy-2.2.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:de749064336d37e340f640b05f24e9e3dd678c57318c7289d222a8a2f543e90c", size = 14119362, upload-time = "2025-05-17T21:35:01.241Z" }, + { url = "https://files.pythonhosted.org/packages/3c/65/4baa99f1c53b30adf0acd9a5519078871ddde8d2339dc5a7fde80d9d87da/numpy-2.2.6-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:894b3a42502226a1cac872f840030665f33326fc3dac8e57c607905773cdcde3", size = 5084103, upload-time = "2025-05-17T21:35:10.622Z" }, + { url = "https://files.pythonhosted.org/packages/cc/89/e5a34c071a0570cc40c9a54eb472d113eea6d002e9ae12bb3a8407fb912e/numpy-2.2.6-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:71594f7c51a18e728451bb50cc60a3ce4e6538822731b2933209a1f3614e9282", size = 6625382, upload-time = "2025-05-17T21:35:21.414Z" }, + { url = "https://files.pythonhosted.org/packages/f8/35/8c80729f1ff76b3921d5c9487c7ac3de9b2a103b1cd05e905b3090513510/numpy-2.2.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f2618db89be1b4e05f7a1a847a9c1c0abd63e63a1607d892dd54668dd92faf87", size = 14018462, upload-time = "2025-05-17T21:35:42.174Z" }, + { url = "https://files.pythonhosted.org/packages/8c/3d/1e1db36cfd41f895d266b103df00ca5b3cbe965184df824dec5c08c6b803/numpy-2.2.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd83c01228a688733f1ded5201c678f0c53ecc1006ffbc404db9f7a899ac6249", size = 16527618, upload-time = "2025-05-17T21:36:06.711Z" }, + { url = "https://files.pythonhosted.org/packages/61/c6/03ed30992602c85aa3cd95b9070a514f8b3c33e31124694438d88809ae36/numpy-2.2.6-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37c0ca431f82cd5fa716eca9506aefcabc247fb27ba69c5062a6d3ade8cf8f49", size = 15505511, upload-time = "2025-05-17T21:36:29.965Z" }, + { url = "https://files.pythonhosted.org/packages/b7/25/5761d832a81df431e260719ec45de696414266613c9ee268394dd5ad8236/numpy-2.2.6-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fe27749d33bb772c80dcd84ae7e8df2adc920ae8297400dabec45f0dedb3f6de", size = 18313783, upload-time = "2025-05-17T21:36:56.883Z" }, + { url = "https://files.pythonhosted.org/packages/57/0a/72d5a3527c5ebffcd47bde9162c39fae1f90138c961e5296491ce778e682/numpy-2.2.6-cp312-cp312-win32.whl", hash = "sha256:4eeaae00d789f66c7a25ac5f34b71a7035bb474e679f410e5e1a94deb24cf2d4", size = 6246506, upload-time = "2025-05-17T21:37:07.368Z" }, + { url = "https://files.pythonhosted.org/packages/36/fa/8c9210162ca1b88529ab76b41ba02d433fd54fecaf6feb70ef9f124683f1/numpy-2.2.6-cp312-cp312-win_amd64.whl", hash = "sha256:c1f9540be57940698ed329904db803cf7a402f3fc200bfe599334c9bd84a40b2", size = 12614190, upload-time = "2025-05-17T21:37:26.213Z" }, + { url = "https://files.pythonhosted.org/packages/f9/5c/6657823f4f594f72b5471f1db1ab12e26e890bb2e41897522d134d2a3e81/numpy-2.2.6-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0811bb762109d9708cca4d0b13c4f67146e3c3b7cf8d34018c722adb2d957c84", size = 20867828, upload-time = "2025-05-17T21:37:56.699Z" }, + { url = "https://files.pythonhosted.org/packages/dc/9e/14520dc3dadf3c803473bd07e9b2bd1b69bc583cb2497b47000fed2fa92f/numpy-2.2.6-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:287cc3162b6f01463ccd86be154f284d0893d2b3ed7292439ea97eafa8170e0b", size = 14143006, upload-time = "2025-05-17T21:38:18.291Z" }, + { url = "https://files.pythonhosted.org/packages/4f/06/7e96c57d90bebdce9918412087fc22ca9851cceaf5567a45c1f404480e9e/numpy-2.2.6-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f1372f041402e37e5e633e586f62aa53de2eac8d98cbfb822806ce4bbefcb74d", size = 5076765, upload-time = "2025-05-17T21:38:27.319Z" }, + { url = "https://files.pythonhosted.org/packages/73/ed/63d920c23b4289fdac96ddbdd6132e9427790977d5457cd132f18e76eae0/numpy-2.2.6-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:55a4d33fa519660d69614a9fad433be87e5252f4b03850642f88993f7b2ca566", size = 6617736, upload-time = "2025-05-17T21:38:38.141Z" }, + { url = "https://files.pythonhosted.org/packages/85/c5/e19c8f99d83fd377ec8c7e0cf627a8049746da54afc24ef0a0cb73d5dfb5/numpy-2.2.6-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f92729c95468a2f4f15e9bb94c432a9229d0d50de67304399627a943201baa2f", size = 14010719, upload-time = "2025-05-17T21:38:58.433Z" }, + { url = "https://files.pythonhosted.org/packages/19/49/4df9123aafa7b539317bf6d342cb6d227e49f7a35b99c287a6109b13dd93/numpy-2.2.6-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bc23a79bfabc5d056d106f9befb8d50c31ced2fbc70eedb8155aec74a45798f", size = 16526072, upload-time = "2025-05-17T21:39:22.638Z" }, + { url = "https://files.pythonhosted.org/packages/b2/6c/04b5f47f4f32f7c2b0e7260442a8cbcf8168b0e1a41ff1495da42f42a14f/numpy-2.2.6-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:e3143e4451880bed956e706a3220b4e5cf6172ef05fcc397f6f36a550b1dd868", size = 15503213, upload-time = "2025-05-17T21:39:45.865Z" }, + { url = "https://files.pythonhosted.org/packages/17/0a/5cd92e352c1307640d5b6fec1b2ffb06cd0dabe7d7b8227f97933d378422/numpy-2.2.6-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b4f13750ce79751586ae2eb824ba7e1e8dba64784086c98cdbbcc6a42112ce0d", size = 18316632, upload-time = "2025-05-17T21:40:13.331Z" }, + { url = "https://files.pythonhosted.org/packages/f0/3b/5cba2b1d88760ef86596ad0f3d484b1cbff7c115ae2429678465057c5155/numpy-2.2.6-cp313-cp313-win32.whl", hash = "sha256:5beb72339d9d4fa36522fc63802f469b13cdbe4fdab4a288f0c441b74272ebfd", size = 6244532, upload-time = "2025-05-17T21:43:46.099Z" }, + { url = "https://files.pythonhosted.org/packages/cb/3b/d58c12eafcb298d4e6d0d40216866ab15f59e55d148a5658bb3132311fcf/numpy-2.2.6-cp313-cp313-win_amd64.whl", hash = "sha256:b0544343a702fa80c95ad5d3d608ea3599dd54d4632df855e4c8d24eb6ecfa1c", size = 12610885, upload-time = "2025-05-17T21:44:05.145Z" }, + { url = "https://files.pythonhosted.org/packages/6b/9e/4bf918b818e516322db999ac25d00c75788ddfd2d2ade4fa66f1f38097e1/numpy-2.2.6-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0bca768cd85ae743b2affdc762d617eddf3bcf8724435498a1e80132d04879e6", size = 20963467, upload-time = "2025-05-17T21:40:44Z" }, + { url = "https://files.pythonhosted.org/packages/61/66/d2de6b291507517ff2e438e13ff7b1e2cdbdb7cb40b3ed475377aece69f9/numpy-2.2.6-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:fc0c5673685c508a142ca65209b4e79ed6740a4ed6b2267dbba90f34b0b3cfda", size = 14225144, upload-time = "2025-05-17T21:41:05.695Z" }, + { url = "https://files.pythonhosted.org/packages/e4/25/480387655407ead912e28ba3a820bc69af9adf13bcbe40b299d454ec011f/numpy-2.2.6-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:5bd4fc3ac8926b3819797a7c0e2631eb889b4118a9898c84f585a54d475b7e40", size = 5200217, upload-time = "2025-05-17T21:41:15.903Z" }, + { url = "https://files.pythonhosted.org/packages/aa/4a/6e313b5108f53dcbf3aca0c0f3e9c92f4c10ce57a0a721851f9785872895/numpy-2.2.6-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:fee4236c876c4e8369388054d02d0e9bb84821feb1a64dd59e137e6511a551f8", size = 6712014, upload-time = "2025-05-17T21:41:27.321Z" }, + { url = "https://files.pythonhosted.org/packages/b7/30/172c2d5c4be71fdf476e9de553443cf8e25feddbe185e0bd88b096915bcc/numpy-2.2.6-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e1dda9c7e08dc141e0247a5b8f49cf05984955246a327d4c48bda16821947b2f", size = 14077935, upload-time = "2025-05-17T21:41:49.738Z" }, + { url = "https://files.pythonhosted.org/packages/12/fb/9e743f8d4e4d3c710902cf87af3512082ae3d43b945d5d16563f26ec251d/numpy-2.2.6-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f447e6acb680fd307f40d3da4852208af94afdfab89cf850986c3ca00562f4fa", size = 16600122, upload-time = "2025-05-17T21:42:14.046Z" }, + { url = "https://files.pythonhosted.org/packages/12/75/ee20da0e58d3a66f204f38916757e01e33a9737d0b22373b3eb5a27358f9/numpy-2.2.6-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:389d771b1623ec92636b0786bc4ae56abafad4a4c513d36a55dce14bd9ce8571", size = 15586143, upload-time = "2025-05-17T21:42:37.464Z" }, + { url = "https://files.pythonhosted.org/packages/76/95/bef5b37f29fc5e739947e9ce5179ad402875633308504a52d188302319c8/numpy-2.2.6-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e9ace4a37db23421249ed236fdcdd457d671e25146786dfc96835cd951aa7c1", size = 18385260, upload-time = "2025-05-17T21:43:05.189Z" }, + { url = "https://files.pythonhosted.org/packages/09/04/f2f83279d287407cf36a7a8053a5abe7be3622a4363337338f2585e4afda/numpy-2.2.6-cp313-cp313t-win32.whl", hash = "sha256:038613e9fb8c72b0a41f025a7e4c3f0b7a1b5d768ece4796b674c8f3fe13efff", size = 6377225, upload-time = "2025-05-17T21:43:16.254Z" }, + { url = "https://files.pythonhosted.org/packages/67/0e/35082d13c09c02c011cf21570543d202ad929d961c02a147493cb0c2bdf5/numpy-2.2.6-cp313-cp313t-win_amd64.whl", hash = "sha256:6031dd6dfecc0cf9f668681a37648373bddd6421fff6c66ec1624eed0180ee06", size = 12771374, upload-time = "2025-05-17T21:43:35.479Z" }, + { url = "https://files.pythonhosted.org/packages/9e/3b/d94a75f4dbf1ef5d321523ecac21ef23a3cd2ac8b78ae2aac40873590229/numpy-2.2.6-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0b605b275d7bd0c640cad4e5d30fa701a8d59302e127e5f79138ad62762c3e3d", size = 21040391, upload-time = "2025-05-17T21:44:35.948Z" }, + { url = "https://files.pythonhosted.org/packages/17/f4/09b2fa1b58f0fb4f7c7963a1649c64c4d315752240377ed74d9cd878f7b5/numpy-2.2.6-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:7befc596a7dc9da8a337f79802ee8adb30a552a94f792b9c9d18c840055907db", size = 6786754, upload-time = "2025-05-17T21:44:47.446Z" }, + { url = "https://files.pythonhosted.org/packages/af/30/feba75f143bdc868a1cc3f44ccfa6c4b9ec522b36458e738cd00f67b573f/numpy-2.2.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce47521a4754c8f4593837384bd3424880629f718d87c5d44f8ed763edd63543", size = 16643476, upload-time = "2025-05-17T21:45:11.871Z" }, + { url = "https://files.pythonhosted.org/packages/37/48/ac2a9584402fb6c0cd5b5d1a91dcf176b15760130dd386bbafdbfe3640bf/numpy-2.2.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:d042d24c90c41b54fd506da306759e06e568864df8ec17ccc17e9e884634fd00", size = 12812666, upload-time = "2025-05-17T21:45:31.426Z" }, +] + +[[package]] +name = "numpy" +version = "2.4.4" +source = { registry = "https://pypi.org/simple" } +resolution-markers = [ + "python_full_version >= '3.12'", + "python_full_version == '3.11.*'", +] +sdist = { url = "https://files.pythonhosted.org/packages/d7/9f/b8cef5bffa569759033adda9481211426f12f53299629b410340795c2514/numpy-2.4.4.tar.gz", hash = "sha256:2d390634c5182175533585cc89f3608a4682ccb173cc9bb940b2881c8d6f8fa0", size = 20731587, upload-time = "2026-03-29T13:22:01.298Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ef/c6/4218570d8c8ecc9704b5157a3348e486e84ef4be0ed3e38218ab473c83d2/numpy-2.4.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f983334aea213c99992053ede6168500e5f086ce74fbc4acc3f2b00f5762e9db", size = 16976799, upload-time = "2026-03-29T13:18:15.438Z" }, + { url = "https://files.pythonhosted.org/packages/dd/92/b4d922c4a5f5dab9ed44e6153908a5c665b71acf183a83b93b690996e39b/numpy-2.4.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:72944b19f2324114e9dc86a159787333b77874143efcf89a5167ef83cfee8af0", size = 14971552, upload-time = "2026-03-29T13:18:18.606Z" }, + { url = "https://files.pythonhosted.org/packages/8a/dc/df98c095978fa6ee7b9a9387d1d58cbb3d232d0e69ad169a4ce784bde4fd/numpy-2.4.4-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:86b6f55f5a352b48d7fbfd2dbc3d5b780b2d79f4d3c121f33eb6efb22e9a2015", size = 5476566, upload-time = "2026-03-29T13:18:21.532Z" }, + { url = "https://files.pythonhosted.org/packages/28/34/b3fdcec6e725409223dd27356bdf5a3c2cc2282e428218ecc9cb7acc9763/numpy-2.4.4-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:ba1f4fc670ed79f876f70082eff4f9583c15fb9a4b89d6188412de4d18ae2f40", size = 6806482, upload-time = "2026-03-29T13:18:23.634Z" }, + { url = "https://files.pythonhosted.org/packages/68/62/63417c13aa35d57bee1337c67446761dc25ea6543130cf868eace6e8157b/numpy-2.4.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a87ec22c87be071b6bdbd27920b129b94f2fc964358ce38f3822635a3e2e03d", size = 15973376, upload-time = "2026-03-29T13:18:26.677Z" }, + { url = "https://files.pythonhosted.org/packages/cf/c5/9fcb7e0e69cef59cf10c746b84f7d58b08bc66a6b7d459783c5a4f6101a6/numpy-2.4.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:df3775294accfdd75f32c74ae39fcba920c9a378a2fc18a12b6820aa8c1fb502", size = 16925137, upload-time = "2026-03-29T13:18:30.14Z" }, + { url = "https://files.pythonhosted.org/packages/7e/43/80020edacb3f84b9efdd1591120a4296462c23fd8db0dde1666f6ef66f13/numpy-2.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d4e437e295f18ec29bc79daf55e8a47a9113df44d66f702f02a293d93a2d6dd", size = 17329414, upload-time = "2026-03-29T13:18:33.733Z" }, + { url = "https://files.pythonhosted.org/packages/fd/06/af0658593b18a5f73532d377188b964f239eb0894e664a6c12f484472f97/numpy-2.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6aa3236c78803afbcb255045fbef97a9e25a1f6c9888357d205ddc42f4d6eba5", size = 18658397, upload-time = "2026-03-29T13:18:37.511Z" }, + { url = "https://files.pythonhosted.org/packages/e6/ce/13a09ed65f5d0ce5c7dd0669250374c6e379910f97af2c08c57b0608eee4/numpy-2.4.4-cp311-cp311-win32.whl", hash = "sha256:30caa73029a225b2d40d9fae193e008e24b2026b7ee1a867b7ee8d96ca1a448e", size = 6239499, upload-time = "2026-03-29T13:18:40.372Z" }, + { url = "https://files.pythonhosted.org/packages/bd/63/05d193dbb4b5eec1eca73822d80da98b511f8328ad4ae3ca4caf0f4db91d/numpy-2.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:6bbe4eb67390b0a0265a2c25458f6b90a409d5d069f1041e6aff1e27e3d9a79e", size = 12614257, upload-time = "2026-03-29T13:18:42.95Z" }, + { url = "https://files.pythonhosted.org/packages/87/c5/8168052f080c26fa984c413305012be54741c9d0d74abd7fbeeccae3889f/numpy-2.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:fcfe2045fd2e8f3cb0ce9d4ba6dba6333b8fa05bb8a4939c908cd43322d14c7e", size = 10486775, upload-time = "2026-03-29T13:18:45.835Z" }, + { url = "https://files.pythonhosted.org/packages/28/05/32396bec30fb2263770ee910142f49c1476d08e8ad41abf8403806b520ce/numpy-2.4.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:15716cfef24d3a9762e3acdf87e27f58dc823d1348f765bbea6bef8c639bfa1b", size = 16689272, upload-time = "2026-03-29T13:18:49.223Z" }, + { url = "https://files.pythonhosted.org/packages/c5/f3/a983d28637bfcd763a9c7aafdb6d5c0ebf3d487d1e1459ffdb57e2f01117/numpy-2.4.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:23cbfd4c17357c81021f21540da84ee282b9c8fba38a03b7b9d09ba6b951421e", size = 14699573, upload-time = "2026-03-29T13:18:52.629Z" }, + { url = "https://files.pythonhosted.org/packages/9b/fd/e5ecca1e78c05106d98028114f5c00d3eddb41207686b2b7de3e477b0e22/numpy-2.4.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:8b3b60bb7cba2c8c81837661c488637eee696f59a877788a396d33150c35d842", size = 5204782, upload-time = "2026-03-29T13:18:55.579Z" }, + { url = "https://files.pythonhosted.org/packages/de/2f/702a4594413c1a8632092beae8aba00f1d67947389369b3777aed783fdca/numpy-2.4.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e4a010c27ff6f210ff4c6ef34394cd61470d01014439b192ec22552ee867f2a8", size = 6552038, upload-time = "2026-03-29T13:18:57.769Z" }, + { url = "https://files.pythonhosted.org/packages/7f/37/eed308a8f56cba4d1fdf467a4fc67ef4ff4bf1c888f5fc980481890104b1/numpy-2.4.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f9e75681b59ddaa5e659898085ae0eaea229d054f2ac0c7e563a62205a700121", size = 15670666, upload-time = "2026-03-29T13:19:00.341Z" }, + { url = "https://files.pythonhosted.org/packages/0a/0d/0e3ecece05b7a7e87ab9fb587855548da437a061326fff64a223b6dcb78a/numpy-2.4.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:81f4a14bee47aec54f883e0cad2d73986640c1590eb9bfaaba7ad17394481e6e", size = 16645480, upload-time = "2026-03-29T13:19:03.63Z" }, + { url = "https://files.pythonhosted.org/packages/34/49/f2312c154b82a286758ee2f1743336d50651f8b5195db18cdb63675ff649/numpy-2.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:62d6b0f03b694173f9fcb1fb317f7222fd0b0b103e784c6549f5e53a27718c44", size = 17020036, upload-time = "2026-03-29T13:19:07.428Z" }, + { url = "https://files.pythonhosted.org/packages/7b/e9/736d17bd77f1b0ec4f9901aaec129c00d59f5d84d5e79bba540ef12c2330/numpy-2.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fbc356aae7adf9e6336d336b9c8111d390a05df88f1805573ebb0807bd06fd1d", size = 18368643, upload-time = "2026-03-29T13:19:10.775Z" }, + { url = "https://files.pythonhosted.org/packages/63/f6/d417977c5f519b17c8a5c3bc9e8304b0908b0e21136fe43bf628a1343914/numpy-2.4.4-cp312-cp312-win32.whl", hash = "sha256:0d35aea54ad1d420c812bfa0385c71cd7cc5bcf7c65fed95fc2cd02fe8c79827", size = 5961117, upload-time = "2026-03-29T13:19:13.464Z" }, + { url = "https://files.pythonhosted.org/packages/2d/5b/e1deebf88ff431b01b7406ca3583ab2bbb90972bbe1c568732e49c844f7e/numpy-2.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:b5f0362dc928a6ecd9db58868fca5e48485205e3855957bdedea308f8672ea4a", size = 12320584, upload-time = "2026-03-29T13:19:16.155Z" }, + { url = "https://files.pythonhosted.org/packages/58/89/e4e856ac82a68c3ed64486a544977d0e7bdd18b8da75b78a577ca31c4395/numpy-2.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:846300f379b5b12cc769334464656bc882e0735d27d9726568bc932fdc49d5ec", size = 10221450, upload-time = "2026-03-29T13:19:18.994Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d0a583ce4fefcc3308806a749a536c201ed6b5ad6e1322e227ee4848979d/numpy-2.4.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:08f2e31ed5e6f04b118e49821397f12767934cfdd12a1ce86a058f91e004ee50", size = 16684933, upload-time = "2026-03-29T13:19:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/c1/62/2b7a48fbb745d344742c0277f01286dead15f3f68e4f359fbfcf7b48f70f/numpy-2.4.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e823b8b6edc81e747526f70f71a9c0a07ac4e7ad13020aa736bb7c9d67196115", size = 14694532, upload-time = "2026-03-29T13:19:25.581Z" }, + { url = "https://files.pythonhosted.org/packages/e5/87/499737bfba066b4a3bebff24a8f1c5b2dee410b209bc6668c9be692580f0/numpy-2.4.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:4a19d9dba1a76618dd86b164d608566f393f8ec6ac7c44f0cc879011c45e65af", size = 5199661, upload-time = "2026-03-29T13:19:28.31Z" }, + { url = "https://files.pythonhosted.org/packages/cd/da/464d551604320d1491bc345efed99b4b7034143a85787aab78d5691d5a0e/numpy-2.4.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d2a8490669bfe99a233298348acc2d824d496dee0e66e31b66a6022c2ad74a5c", size = 6547539, upload-time = "2026-03-29T13:19:30.97Z" }, + { url = "https://files.pythonhosted.org/packages/7d/90/8d23e3b0dafd024bf31bdec225b3bb5c2dbfa6912f8a53b8659f21216cbf/numpy-2.4.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:45dbed2ab436a9e826e302fcdcbe9133f9b0006e5af7168afb8963a6520da103", size = 15668806, upload-time = "2026-03-29T13:19:33.887Z" }, + { url = "https://files.pythonhosted.org/packages/d1/73/a9d864e42a01896bb5974475438f16086be9ba1f0d19d0bb7a07427c4a8b/numpy-2.4.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c901b15172510173f5cb310eae652908340f8dede90fff9e3bf6c0d8dfd92f83", size = 16632682, upload-time = "2026-03-29T13:19:37.336Z" }, + { url = "https://files.pythonhosted.org/packages/34/fb/14570d65c3bde4e202a031210475ae9cde9b7686a2e7dc97ee67d2833b35/numpy-2.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:99d838547ace2c4aace6c4f76e879ddfe02bb58a80c1549928477862b7a6d6ed", size = 17019810, upload-time = "2026-03-29T13:19:40.963Z" }, + { url = "https://files.pythonhosted.org/packages/8a/77/2ba9d87081fd41f6d640c83f26fb7351e536b7ce6dd9061b6af5904e8e46/numpy-2.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0aec54fd785890ecca25a6003fd9a5aed47ad607bbac5cd64f836ad8666f4959", size = 18357394, upload-time = "2026-03-29T13:19:44.859Z" }, + { url = "https://files.pythonhosted.org/packages/a2/23/52666c9a41708b0853fa3b1a12c90da38c507a3074883823126d4e9d5b30/numpy-2.4.4-cp313-cp313-win32.whl", hash = "sha256:07077278157d02f65c43b1b26a3886bce886f95d20aabd11f87932750dfb14ed", size = 5959556, upload-time = "2026-03-29T13:19:47.661Z" }, + { url = "https://files.pythonhosted.org/packages/57/fb/48649b4971cde70d817cf97a2a2fdc0b4d8308569f1dd2f2611959d2e0cf/numpy-2.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:5c70f1cc1c4efbe316a572e2d8b9b9cc44e89b95f79ca3331553fbb63716e2bf", size = 12317311, upload-time = "2026-03-29T13:19:50.67Z" }, + { url = "https://files.pythonhosted.org/packages/ba/d8/11490cddd564eb4de97b4579ef6bfe6a736cc07e94c1598590ae25415e01/numpy-2.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:ef4059d6e5152fa1a39f888e344c73fdc926e1b2dd58c771d67b0acfbf2aa67d", size = 10222060, upload-time = "2026-03-29T13:19:54.229Z" }, + { url = "https://files.pythonhosted.org/packages/99/5d/dab4339177a905aad3e2221c915b35202f1ec30d750dd2e5e9d9a72b804b/numpy-2.4.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4bbc7f303d125971f60ec0aaad5e12c62d0d2c925f0ab1273debd0e4ba37aba5", size = 14822302, upload-time = "2026-03-29T13:19:57.585Z" }, + { url = "https://files.pythonhosted.org/packages/eb/e4/0564a65e7d3d97562ed6f9b0fd0fb0a6f559ee444092f105938b50043876/numpy-2.4.4-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:4d6d57903571f86180eb98f8f0c839fa9ebbfb031356d87f1361be91e433f5b7", size = 5327407, upload-time = "2026-03-29T13:20:00.601Z" }, + { url = "https://files.pythonhosted.org/packages/29/8d/35a3a6ce5ad371afa58b4700f1c820f8f279948cca32524e0a695b0ded83/numpy-2.4.4-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:4636de7fd195197b7535f231b5de9e4b36d2c440b6e566d2e4e4746e6af0ca93", size = 6647631, upload-time = "2026-03-29T13:20:02.855Z" }, + { url = "https://files.pythonhosted.org/packages/f4/da/477731acbd5a58a946c736edfdabb2ac5b34c3d08d1ba1a7b437fa0884df/numpy-2.4.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ad2e2ef14e0b04e544ea2fa0a36463f847f113d314aa02e5b402fdf910ef309e", size = 15727691, upload-time = "2026-03-29T13:20:06.004Z" }, + { url = "https://files.pythonhosted.org/packages/e6/db/338535d9b152beabeb511579598418ba0212ce77cf9718edd70262cc4370/numpy-2.4.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a285b3b96f951841799528cd1f4f01cd70e7e0204b4abebac9463eecfcf2a40", size = 16681241, upload-time = "2026-03-29T13:20:09.417Z" }, + { url = "https://files.pythonhosted.org/packages/e2/a9/ad248e8f58beb7a0219b413c9c7d8151c5d285f7f946c3e26695bdbbe2df/numpy-2.4.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8474c4241bc18b750be2abea9d7a9ec84f46ef861dbacf86a4f6e043401f79e", size = 17085767, upload-time = "2026-03-29T13:20:13.126Z" }, + { url = "https://files.pythonhosted.org/packages/b5/1a/3b88ccd3694681356f70da841630e4725a7264d6a885c8d442a697e1146b/numpy-2.4.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4e874c976154687c1f71715b034739b45c7711bec81db01914770373d125e392", size = 18403169, upload-time = "2026-03-29T13:20:17.096Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c9/fcfd5d0639222c6eac7f304829b04892ef51c96a75d479214d77e3ce6e33/numpy-2.4.4-cp313-cp313t-win32.whl", hash = "sha256:9c585a1790d5436a5374bac930dad6ed244c046ed91b2b2a3634eb2971d21008", size = 6083477, upload-time = "2026-03-29T13:20:20.195Z" }, + { url = "https://files.pythonhosted.org/packages/d5/e3/3938a61d1c538aaec8ed6fd6323f57b0c2d2d2219512434c5c878db76553/numpy-2.4.4-cp313-cp313t-win_amd64.whl", hash = "sha256:93e15038125dc1e5345d9b5b68aa7f996ec33b98118d18c6ca0d0b7d6198b7e8", size = 12457487, upload-time = "2026-03-29T13:20:22.946Z" }, + { url = "https://files.pythonhosted.org/packages/97/6a/7e345032cc60501721ef94e0e30b60f6b0bd601f9174ebd36389a2b86d40/numpy-2.4.4-cp313-cp313t-win_arm64.whl", hash = "sha256:0dfd3f9d3adbe2920b68b5cd3d51444e13a10792ec7154cd0a2f6e74d4ab3233", size = 10292002, upload-time = "2026-03-29T13:20:25.909Z" }, + { url = "https://files.pythonhosted.org/packages/6e/06/c54062f85f673dd5c04cbe2f14c3acb8c8b95e3384869bb8cc9bff8cb9df/numpy-2.4.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:f169b9a863d34f5d11b8698ead99febeaa17a13ca044961aa8e2662a6c7766a0", size = 16684353, upload-time = "2026-03-29T13:20:29.504Z" }, + { url = "https://files.pythonhosted.org/packages/4c/39/8a320264a84404c74cc7e79715de85d6130fa07a0898f67fb5cd5bd79908/numpy-2.4.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2483e4584a1cb3092da4470b38866634bafb223cbcd551ee047633fd2584599a", size = 14704914, upload-time = "2026-03-29T13:20:33.547Z" }, + { url = "https://files.pythonhosted.org/packages/91/fb/287076b2614e1d1044235f50f03748f31fa287e3dbe6abeb35cdfa351eca/numpy-2.4.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:2d19e6e2095506d1736b7d80595e0f252d76b89f5e715c35e06e937679ea7d7a", size = 5210005, upload-time = "2026-03-29T13:20:36.45Z" }, + { url = "https://files.pythonhosted.org/packages/63/eb/fcc338595309910de6ecabfcef2419a9ce24399680bfb149421fa2df1280/numpy-2.4.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:6a246d5914aa1c820c9443ddcee9c02bec3e203b0c080349533fae17727dfd1b", size = 6544974, upload-time = "2026-03-29T13:20:39.014Z" }, + { url = "https://files.pythonhosted.org/packages/44/5d/e7e9044032a716cdfaa3fba27a8e874bf1c5f1912a1ddd4ed071bf8a14a6/numpy-2.4.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:989824e9faf85f96ec9c7761cd8d29c531ad857bfa1daa930cba85baaecf1a9a", size = 15684591, upload-time = "2026-03-29T13:20:42.146Z" }, + { url = "https://files.pythonhosted.org/packages/98/7c/21252050676612625449b4807d6b695b9ce8a7c9e1c197ee6216c8a65c7c/numpy-2.4.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:27a8d92cd10f1382a67d7cf4db7ce18341b66438bdd9f691d7b0e48d104c2a9d", size = 16637700, upload-time = "2026-03-29T13:20:46.204Z" }, + { url = "https://files.pythonhosted.org/packages/b1/29/56d2bbef9465db24ef25393383d761a1af4f446a1df9b8cded4fe3a5a5d7/numpy-2.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e44319a2953c738205bf3354537979eaa3998ed673395b964c1176083dd46252", size = 17035781, upload-time = "2026-03-29T13:20:50.242Z" }, + { url = "https://files.pythonhosted.org/packages/e3/2b/a35a6d7589d21f44cea7d0a98de5ddcbb3d421b2622a5c96b1edf18707c3/numpy-2.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e892aff75639bbef0d2a2cfd55535510df26ff92f63c92cd84ef8d4ba5a5557f", size = 18362959, upload-time = "2026-03-29T13:20:54.019Z" }, + { url = "https://files.pythonhosted.org/packages/64/c9/d52ec581f2390e0f5f85cbfd80fb83d965fc15e9f0e1aec2195faa142cde/numpy-2.4.4-cp314-cp314-win32.whl", hash = "sha256:1378871da56ca8943c2ba674530924bb8ca40cd228358a3b5f302ad60cf875fc", size = 6008768, upload-time = "2026-03-29T13:20:56.912Z" }, + { url = "https://files.pythonhosted.org/packages/fa/22/4cc31a62a6c7b74a8730e31a4274c5dc80e005751e277a2ce38e675e4923/numpy-2.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:715d1c092715954784bc79e1174fc2a90093dc4dc84ea15eb14dad8abdcdeb74", size = 12449181, upload-time = "2026-03-29T13:20:59.548Z" }, + { url = "https://files.pythonhosted.org/packages/70/2e/14cda6f4d8e396c612d1bf97f22958e92148801d7e4f110cabebdc0eef4b/numpy-2.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:2c194dd721e54ecad9ad387c1d35e63dce5c4450c6dc7dd5611283dda239aabb", size = 10496035, upload-time = "2026-03-29T13:21:02.524Z" }, + { url = "https://files.pythonhosted.org/packages/b1/e8/8fed8c8d848d7ecea092dc3469643f9d10bc3a134a815a3b033da1d2039b/numpy-2.4.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2aa0613a5177c264ff5921051a5719d20095ea586ca88cc802c5c218d1c67d3e", size = 14824958, upload-time = "2026-03-29T13:21:05.671Z" }, + { url = "https://files.pythonhosted.org/packages/05/1a/d8007a5138c179c2bf33ef44503e83d70434d2642877ee8fbb230e7c0548/numpy-2.4.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:42c16925aa5a02362f986765f9ebabf20de75cdefdca827d14315c568dcab113", size = 5330020, upload-time = "2026-03-29T13:21:08.635Z" }, + { url = "https://files.pythonhosted.org/packages/99/64/ffb99ac6ae93faf117bcbd5c7ba48a7f45364a33e8e458545d3633615dda/numpy-2.4.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:874f200b2a981c647340f841730fc3a2b54c9d940566a3c4149099591e2c4c3d", size = 6650758, upload-time = "2026-03-29T13:21:10.949Z" }, + { url = "https://files.pythonhosted.org/packages/6e/6e/795cc078b78a384052e73b2f6281ff7a700e9bf53bcce2ee579d4f6dd879/numpy-2.4.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c9b39d38a9bd2ae1becd7eac1303d031c5c110ad31f2b319c6e7d98b135c934d", size = 15729948, upload-time = "2026-03-29T13:21:14.047Z" }, + { url = "https://files.pythonhosted.org/packages/5f/86/2acbda8cc2af5f3d7bfc791192863b9e3e19674da7b5e533fded124d1299/numpy-2.4.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b268594bccac7d7cf5844c7732e3f20c50921d94e36d7ec9b79e9857694b1b2f", size = 16679325, upload-time = "2026-03-29T13:21:17.561Z" }, + { url = "https://files.pythonhosted.org/packages/bc/59/cafd83018f4aa55e0ac6fa92aa066c0a1877b77a615ceff1711c260ffae8/numpy-2.4.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ac6b31e35612a26483e20750126d30d0941f949426974cace8e6b5c58a3657b0", size = 17084883, upload-time = "2026-03-29T13:21:21.106Z" }, + { url = "https://files.pythonhosted.org/packages/f0/85/a42548db84e65ece46ab2caea3d3f78b416a47af387fcbb47ec28e660dc2/numpy-2.4.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8e3ed142f2728df44263aaf5fb1f5b0b99f4070c553a0d7f033be65338329150", size = 18403474, upload-time = "2026-03-29T13:21:24.828Z" }, + { url = "https://files.pythonhosted.org/packages/ed/ad/483d9e262f4b831000062e5d8a45e342166ec8aaa1195264982bca267e62/numpy-2.4.4-cp314-cp314t-win32.whl", hash = "sha256:dddbbd259598d7240b18c9d87c56a9d2fb3b02fe266f49a7c101532e78c1d871", size = 6155500, upload-time = "2026-03-29T13:21:28.205Z" }, + { url = "https://files.pythonhosted.org/packages/c7/03/2fc4e14c7bd4ff2964b74ba90ecb8552540b6315f201df70f137faa5c589/numpy-2.4.4-cp314-cp314t-win_amd64.whl", hash = "sha256:a7164afb23be6e37ad90b2f10426149fd75aee07ca55653d2aa41e66c4ef697e", size = 12637755, upload-time = "2026-03-29T13:21:31.107Z" }, + { url = "https://files.pythonhosted.org/packages/58/78/548fb8e07b1a341746bfbecb32f2c268470f45fa028aacdbd10d9bc73aab/numpy-2.4.4-cp314-cp314t-win_arm64.whl", hash = "sha256:ba203255017337d39f89bdd58417f03c4426f12beed0440cfd933cb15f8669c7", size = 10566643, upload-time = "2026-03-29T13:21:34.339Z" }, + { url = "https://files.pythonhosted.org/packages/6b/33/8fae8f964a4f63ed528264ddf25d2b683d0b663e3cba26961eb838a7c1bd/numpy-2.4.4-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:58c8b5929fcb8287cbd6f0a3fae19c6e03a5c48402ae792962ac465224a629a4", size = 16854491, upload-time = "2026-03-29T13:21:38.03Z" }, + { url = "https://files.pythonhosted.org/packages/bc/d0/1aabee441380b981cf8cdda3ae7a46aa827d1b5a8cce84d14598bc94d6d9/numpy-2.4.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:eea7ac5d2dce4189771cedb559c738a71512768210dc4e4753b107a2048b3d0e", size = 14895830, upload-time = "2026-03-29T13:21:41.509Z" }, + { url = "https://files.pythonhosted.org/packages/a5/b8/aafb0d1065416894fccf4df6b49ef22b8db045187949545bced89c034b8e/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:51fc224f7ca4d92656d5a5eb315f12eb5fe2c97a66249aa7b5f562528a3be38c", size = 5400927, upload-time = "2026-03-29T13:21:44.747Z" }, + { url = "https://files.pythonhosted.org/packages/d6/77/063baa20b08b431038c7f9ff5435540c7b7265c78cf56012a483019ca72d/numpy-2.4.4-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:28a650663f7314afc3e6ec620f44f333c386aad9f6fc472030865dc0ebb26ee3", size = 6715557, upload-time = "2026-03-29T13:21:47.406Z" }, + { url = "https://files.pythonhosted.org/packages/c7/a8/379542d45a14f149444c5c4c4e7714707239ce9cc1de8c2803958889da14/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:19710a9ca9992d7174e9c52f643d4272dcd1558c5f7af7f6f8190f633bd651a7", size = 15804253, upload-time = "2026-03-29T13:21:50.753Z" }, + { url = "https://files.pythonhosted.org/packages/a2/c8/f0a45426d6d21e7ea3310a15cf90c43a14d9232c31a837702dba437f3373/numpy-2.4.4-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9b2aec6af35c113b05695ebb5749a787acd63cafc83086a05771d1e1cd1e555f", size = 16753552, upload-time = "2026-03-29T13:21:54.344Z" }, + { url = "https://files.pythonhosted.org/packages/04/74/f4c001f4714c3ad9ce037e18cf2b9c64871a84951eaa0baf683a9ca9301c/numpy-2.4.4-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f2cf083b324a467e1ab358c105f6cad5ea950f50524668a80c486ff1db24e119", size = 12509075, upload-time = "2026-03-29T13:21:57.644Z" }, +] + +[[package]] +name = "omegaconf" +version = "2.3.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "antlr4-python3-runtime" }, + { name = "pyyaml" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/09/48/6388f1bb9da707110532cb70ec4d2822858ddfb44f1cdf1233c20a80ea4b/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7", size = 3298120, upload-time = "2022-12-08T20:59:22.753Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/e3/94/1843518e420fa3ed6919835845df698c7e27e183cb997394e4a670973a65/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b", size = 79500, upload-time = "2022-12-08T20:59:19.686Z" }, +] + +[[package]] +name = "packaging" +version = "26.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/df/de/0d2b39fb4af88a0258f3bac87dfcbb48e73fbdea4a2ed0e2213f9a4c2f9a/packaging-26.1.tar.gz", hash = "sha256:f042152b681c4bfac5cae2742a55e103d27ab2ec0f3d88037136b6bfe7c9c5de", size = 215519, upload-time = "2026-04-14T21:12:49.362Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/7a/c2/920ef838e2f0028c8262f16101ec09ebd5969864e5a64c4c05fad0617c56/packaging-26.1-py3-none-any.whl", hash = "sha256:5d9c0669c6285e491e0ced2eee587eaf67b670d94a19e94e3984a481aba6802f", size = 95831, upload-time = "2026-04-14T21:12:47.56Z" }, +] + +[[package]] +name = "parso" +version = "0.8.7" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/30/4b/90c937815137d43ce71ba043cd3566221e9df6b9c805f24b5d138c9d40a7/parso-0.8.7.tar.gz", hash = "sha256:eaaac4c9fdd5e9e8852dc778d2d7405897ec510f2a298071453e5e3a07914bb1", size = 401824, upload-time = "2026-05-01T23:13:02.138Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/99/5d/8268b644392ee874ee82a635cd0df1773de230bde356c38de28e298392cc/parso-0.8.7-py2.py3-none-any.whl", hash = "sha256:a8926eb2a1b915486941fdbd31e86a4baf88fe8c210f25f2f35ecec5b574ca1c", size = 107025, upload-time = "2026-05-01T23:12:58.867Z" }, +] + +[[package]] +name = "perlin-noise" +version = "1.14" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/0e/6b92d7ff48004fda3eb2343cd305d3e5c68fe98f31b2d3bbde76201a18f2/perlin_noise-1.14.tar.gz", hash = "sha256:21ab04c26d728904234e38b1354ba2dcc137847d82e8c331f84d0e11a1a4152e", size = 3414, upload-time = "2025-04-12T12:03:14.857Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/6d/35/8747bfef07ac48450f78d167e5c298ca31306c43699841b0b1e805f2fdd4/perlin_noise-1.14-py3-none-any.whl", hash = "sha256:3ecfae6437860c3e51d5f4bac0a7ceea1b9193a4a83c6d775edd5d47a918bc62", size = 4593, upload-time = "2025-04-12T12:03:13.568Z" }, +] + +[[package]] +name = "pettingzoo" +version = "1.25.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gymnasium" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/38/cb/cbb8d0e973b284f709ce93a80354d464588301957220f031c51324b464b2/pettingzoo-1.25.0.tar.gz", hash = "sha256:4b8a8552eab07a9c8f37dca094e59ee194003c57e2a7e7348bdf7c62049eecf6", size = 723959, upload-time = "2025-04-22T14:37:37.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d3/9a/33fb244264573687ef27b2f436ae98b524c5e8e5edc7c36183a59c5b4748/pettingzoo-1.25.0-py3-none-any.whl", hash = "sha256:f385bccbebdad73a0c3da884344aea6e2614aa962b653c790b06ef9ab162d651", size = 852489, upload-time = "2025-04-22T14:37:36.036Z" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/9e/c3/059298687310d527a58bb01f3b1965787ee3b40dce76752eda8b44e9a2c5/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523", size = 63772, upload-time = "2023-11-25T06:56:14.81Z" }, +] + +[[package]] +name = "pillow" +version = "12.2.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/3a/aa/d0b28e1c811cd4d5f5c2bfe2e022292bd255ae5744a3b9ac7d6c8f72dd75/pillow-12.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:a4e8f36e677d3336f35089648c8955c51c6d386a13cf6ee9c189c5f5bd713a9f", size = 5354355, upload-time = "2026-04-01T14:42:15.402Z" }, + { url = "https://files.pythonhosted.org/packages/27/8e/1d5b39b8ae2bd7650d0c7b6abb9602d16043ead9ebbfef4bc4047454da2a/pillow-12.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e589959f10d9824d39b350472b92f0ce3b443c0a3442ebf41c40cb8361c5b97", size = 4695871, upload-time = "2026-04-01T14:42:18.234Z" }, + { url = "https://files.pythonhosted.org/packages/f0/c5/dcb7a6ca6b7d3be41a76958e90018d56c8462166b3ef223150360850c8da/pillow-12.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a52edc8bfff4429aaabdf4d9ee0daadbbf8562364f940937b941f87a4290f5ff", size = 6269734, upload-time = "2026-04-01T14:42:20.608Z" }, + { url = "https://files.pythonhosted.org/packages/ea/f1/aa1bb13b2f4eba914e9637893c73f2af8e48d7d4023b9d3750d4c5eb2d0c/pillow-12.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975385f4776fafde056abb318f612ef6285b10a1f12b8570f3647ad0d74b48ec", size = 8076080, upload-time = "2026-04-01T14:42:23.095Z" }, + { url = "https://files.pythonhosted.org/packages/a1/2a/8c79d6a53169937784604a8ae8d77e45888c41537f7f6f65ed1f407fe66d/pillow-12.2.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd9c0c7a0c681a347b3194c500cb1e6ca9cab053ea4d82a5cf45b6b754560136", size = 6382236, upload-time = "2026-04-01T14:42:25.82Z" }, + { url = "https://files.pythonhosted.org/packages/b5/42/bbcb6051030e1e421d103ce7a8ecadf837aa2f39b8f82ef1a8d37c3d4ebc/pillow-12.2.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88d387ff40b3ff7c274947ed3125dedf5262ec6919d83946753b5f3d7c67ea4c", size = 7070220, upload-time = "2026-04-01T14:42:28.68Z" }, + { url = "https://files.pythonhosted.org/packages/3f/e1/c2a7d6dd8cfa6b231227da096fd2d58754bab3603b9d73bf609d3c18b64f/pillow-12.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c4167c34b0d8ba05b547a3bb23578d0ba17b80a5593f93bd8ecb123dd336a3", size = 6493124, upload-time = "2026-04-01T14:42:31.579Z" }, + { url = "https://files.pythonhosted.org/packages/5f/41/7c8617da5d32e1d2f026e509484fdb6f3ad7efaef1749a0c1928adbb099e/pillow-12.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34c0d99ecccea270c04882cb3b86e7b57296079c9a4aff88cb3b33563d95afaa", size = 7194324, upload-time = "2026-04-01T14:42:34.615Z" }, + { url = "https://files.pythonhosted.org/packages/2d/de/a777627e19fd6d62f84070ee1521adde5eeda4855b5cf60fe0b149118bca/pillow-12.2.0-cp310-cp310-win32.whl", hash = "sha256:b85f66ae9eb53e860a873b858b789217ba505e5e405a24b85c0464822fe88032", size = 6376363, upload-time = "2026-04-01T14:42:37.19Z" }, + { url = "https://files.pythonhosted.org/packages/e7/34/fc4cb5204896465842767b96d250c08410f01f2f28afc43b257de842eed5/pillow-12.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:673aa32138f3e7531ccdbca7b3901dba9b70940a19ccecc6a37c77d5fdeb05b5", size = 7083523, upload-time = "2026-04-01T14:42:39.62Z" }, + { url = "https://files.pythonhosted.org/packages/2d/a0/32852d36bc7709f14dc3f64f929a275e958ad8c19a6deba9610d458e28b3/pillow-12.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:3e080565d8d7c671db5802eedfb438e5565ffa40115216eabb8cd52d0ecce024", size = 2463318, upload-time = "2026-04-01T14:42:42.063Z" }, + { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" }, + { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" }, + { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" }, + { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" }, + { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" }, + { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" }, + { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" }, + { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" }, + { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" }, + { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" }, + { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" }, + { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" }, + { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" }, + { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" }, + { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" }, + { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" }, + { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" }, + { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" }, + { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" }, + { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" }, + { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" }, + { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" }, + { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" }, + { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" }, + { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" }, + { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" }, + { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" }, + { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" }, + { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" }, + { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" }, + { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" }, + { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" }, + { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" }, + { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" }, + { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" }, + { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" }, + { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" }, + { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" }, + { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" }, + { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" }, + { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" }, + { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" }, + { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" }, + { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" }, + { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" }, + { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" }, + { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" }, + { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" }, + { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" }, + { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" }, + { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" }, + { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" }, + { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" }, + { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" }, + { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" }, + { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" }, + { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" }, + { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" }, + { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" }, + { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" }, + { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" }, + { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" }, + { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" }, + { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" }, + { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" }, + { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" }, + { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" }, + { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" }, + { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" }, + { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" }, + { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" }, + { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" }, + { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" }, + { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" }, + { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" }, + { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" }, + { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" }, + { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" }, + { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.6" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/9f/4a/0883b8e3802965322523f0b200ecf33d31f10991d0401162f4b23c698b42/platformdirs-4.9.6.tar.gz", hash = "sha256:3bfa75b0ad0db84096ae777218481852c0ebc6c727b3168c1b9e0118e458cf0a", size = 29400, upload-time = "2026-04-09T00:04:10.812Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/75/a6/a0a304dc33b49145b21f4808d763822111e67d1c3a32b524a1baf947b6e1/platformdirs-4.9.6-py3-none-any.whl", hash = "sha256:e61adb1d5e5cb3441b4b7710bea7e4c12250ca49439228cc1021c00dcfac0917", size = 21348, upload-time = "2026-04-09T00:04:09.463Z" }, +] + +[[package]] +name = "pluggy" +version = "1.6.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f9/e2/3e91f31a7d2b083fe6ef3fa267035b518369d9511ffab804f839851d2779/pluggy-1.6.0.tar.gz", hash = "sha256:7dcc130b76258d33b90f61b658791dede3486c3e6bfb003ee5c9bfb396dd22f3", size = 69412, upload-time = "2025-05-15T12:30:07.975Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" }, +] + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/84/03/0d3ce49e2505ae70cf43bc5bb3033955d2fc9f932163e84dc0779cc47f48/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955", size = 391431, upload-time = "2025-08-27T15:23:59.498Z" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/aa/c6/d1ddf4abb55e93cebc4f2ed8b5d6dbad109ecb8d63748dd2b20ab5e57ebe/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372", size = 493740, upload-time = "2026-01-28T18:14:54.428Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/51/08/510cbdb69c25a96f4ae523f733cdc963ae654904e8db864c07585ef99875/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b", size = 130595, upload-time = "2026-01-28T18:14:57.293Z" }, + { url = "https://files.pythonhosted.org/packages/d6/f5/97baea3fe7a5a9af7436301f85490905379b1c6f2dd51fe3ecf24b4c5fbf/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea", size = 131082, upload-time = "2026-01-28T18:14:59.732Z" }, + { url = "https://files.pythonhosted.org/packages/37/d6/246513fbf9fa174af531f28412297dd05241d97a75911ac8febefa1a53c6/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63", size = 181476, upload-time = "2026-01-28T18:15:01.884Z" }, + { url = "https://files.pythonhosted.org/packages/b8/b5/9182c9af3836cca61696dabe4fd1304e17bc56cb62f17439e1154f225dd3/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312", size = 184062, upload-time = "2026-01-28T18:15:04.436Z" }, + { url = "https://files.pythonhosted.org/packages/16/ba/0756dca669f5a9300d0cbcbfae9a4c30e446dfc7440ffe43ded5724bfd93/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b", size = 139893, upload-time = "2026-01-28T18:15:06.378Z" }, + { url = "https://files.pythonhosted.org/packages/1c/61/8fa0e26f33623b49949346de05ec1ddaad02ed8ba64af45f40a147dbfa97/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9", size = 135589, upload-time = "2026-01-28T18:15:08.03Z" }, + { url = "https://files.pythonhosted.org/packages/81/69/ef179ab5ca24f32acc1dac0c247fd6a13b501fd5534dbae0e05a1c48b66d/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00", size = 130664, upload-time = "2026-01-28T18:15:09.469Z" }, + { url = "https://files.pythonhosted.org/packages/7b/64/665248b557a236d3fa9efc378d60d95ef56dd0a490c2cd37dafc7660d4a9/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9", size = 131087, upload-time = "2026-01-28T18:15:11.724Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2e/e6782744700d6759ebce3043dcfa661fb61e2fb752b91cdeae9af12c2178/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a", size = 182383, upload-time = "2026-01-28T18:15:13.445Z" }, + { url = "https://files.pythonhosted.org/packages/57/49/0a41cefd10cb7505cdc04dab3eacf24c0c2cb158a998b8c7b1d27ee2c1f5/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf", size = 185210, upload-time = "2026-01-28T18:15:16.002Z" }, + { url = "https://files.pythonhosted.org/packages/dd/2c/ff9bfb544f283ba5f83ba725a3c5fec6d6b10b8f27ac1dc641c473dc390d/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1", size = 141228, upload-time = "2026-01-28T18:15:18.385Z" }, + { url = "https://files.pythonhosted.org/packages/f2/fc/f8d9c31db14fcec13748d373e668bc3bed94d9077dbc17fb0eebc073233c/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841", size = 136284, upload-time = "2026-01-28T18:15:19.912Z" }, + { url = "https://files.pythonhosted.org/packages/e7/36/5ee6e05c9bd427237b11b3937ad82bb8ad2752d72c6969314590dd0c2f6e/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486", size = 129090, upload-time = "2026-01-28T18:15:22.168Z" }, + { url = "https://files.pythonhosted.org/packages/80/c4/f5af4c1ca8c1eeb2e92ccca14ce8effdeec651d5ab6053c589b074eda6e1/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979", size = 129859, upload-time = "2026-01-28T18:15:23.795Z" }, + { url = "https://files.pythonhosted.org/packages/b5/70/5d8df3b09e25bce090399cf48e452d25c935ab72dad19406c77f4e828045/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9", size = 155560, upload-time = "2026-01-28T18:15:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/63/65/37648c0c158dc222aba51c089eb3bdfa238e621674dc42d48706e639204f/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e", size = 156997, upload-time = "2026-01-28T18:15:27.794Z" }, + { url = "https://files.pythonhosted.org/packages/8e/13/125093eadae863ce03c6ffdbae9929430d116a246ef69866dad94da3bfbc/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8", size = 148972, upload-time = "2026-01-28T18:15:29.342Z" }, + { url = "https://files.pythonhosted.org/packages/04/78/0acd37ca84ce3ddffaa92ef0f571e073faa6d8ff1f0559ab1272188ea2be/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc", size = 148266, upload-time = "2026-01-28T18:15:31.597Z" }, + { url = "https://files.pythonhosted.org/packages/b4/90/e2159492b5426be0c1fef7acba807a03511f97c5f86b3caeda6ad92351a7/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988", size = 137737, upload-time = "2026-01-28T18:15:33.849Z" }, + { url = "https://files.pythonhosted.org/packages/8c/c7/7bb2e321574b10df20cbde462a94e2b71d05f9bbda251ef27d104668306a/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee", size = 134617, upload-time = "2026-01-28T18:15:36.514Z" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/20/e5/16ff212c1e452235a90aeb09066144d0c5a6a8c0834397e03f5224495c4e/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220", size = 70762, upload-time = "2020-12-28T15:15:30.155Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/22/a6/858897256d0deac81a172289110f31629fc4cee19b6f01283303e18c8db3/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35", size = 13993, upload-time = "2020-12-28T15:15:28.35Z" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/cd/05/0a34433a064256a578f1783a10da6df098ceaa4a57bbeaa96a6c0352786b/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42", size = 19752, upload-time = "2024-07-21T12:58:21.801Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/8e/37/efad0257dc6e593a18957422533ff0f87ede7c9c6ea010a2177d738fb82f/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0", size = 11842, upload-time = "2024-07-21T12:58:20.04Z" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/1b/7d/92392ff7815c21062bea51aa7b87d45576f649f16458d78b7cf94b9ab2e6/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29", size = 103492, upload-time = "2026-01-21T14:26:51.89Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, +] + +[[package]] +name = "pygame" +version = "2.6.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/49/cc/08bba60f00541f62aaa252ce0cfbd60aebd04616c0b9574f755b583e45ae/pygame-2.6.1.tar.gz", hash = "sha256:56fb02ead529cee00d415c3e007f75e0780c655909aaa8e8bf616ee09c9feb1f", size = 14808125, upload-time = "2024-09-29T13:41:34.698Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/54/0b/334c7c50a2979e15f2a027a41d1ca78ee730d5b1c7f7f4b26d7cb899839d/pygame-2.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9beeb647e555afb5657111fa83acb74b99ad88761108eaea66472e8b8547b55b", size = 13109297, upload-time = "2024-09-29T14:25:34.709Z" }, + { url = "https://files.pythonhosted.org/packages/dc/48/f8b1069788d1bd42e63a960d74d3355242480b750173a42b2749687578ca/pygame-2.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:10e3d2a55f001f6c0a6eb44aa79ea7607091c9352b946692acedb2ac1482f1c9", size = 12375837, upload-time = "2024-09-29T14:25:50.538Z" }, + { url = "https://files.pythonhosted.org/packages/bc/33/a1310386b8913ce1bdb90c33fa536970e299ad57eb35785f1d71ea1e2ad3/pygame-2.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:816e85000c5d8b02a42b9834f761a5925ef3377d2924e3a7c4c143d2990ce5b8", size = 13607860, upload-time = "2024-09-29T11:10:44.173Z" }, + { url = "https://files.pythonhosted.org/packages/88/0f/4e37b115056e43714e7550054dd3cd7f4d552da54d7fc58a2fb1407acda5/pygame-2.6.1-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8a78fd030d98faab4a8e27878536fdff7518d3e062a72761c552f624ebba5a5f", size = 14304696, upload-time = "2024-09-29T11:39:46.724Z" }, + { url = "https://files.pythonhosted.org/packages/11/b3/de6ed93ae483cf3bac8f950a955e83f7ffe59651fd804d100fff65d66d6c/pygame-2.6.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:da3ad64d685f84a34ebe5daacb39fff14f1251acb34c098d760d63fee768f50c", size = 13977684, upload-time = "2024-09-29T11:39:49.921Z" }, + { url = "https://files.pythonhosted.org/packages/d3/05/d86440aa879708c41844bafc6b3eb42c6d8cf54082482499b53139133e2a/pygame-2.6.1-cp310-cp310-win32.whl", hash = "sha256:9dd5c054d4bd875a8caf978b82672f02bec332f52a833a76899220c460bb4b58", size = 10251775, upload-time = "2024-09-29T11:40:34.952Z" }, + { url = "https://files.pythonhosted.org/packages/38/88/8de61324775cf2c844a51d8db14a8a6d2a9092312f27678f6eaa3a460376/pygame-2.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:00827aba089355925902d533f9c41e79a799641f03746c50a374dc5c3362e43d", size = 10618801, upload-time = "2024-09-29T12:13:25.284Z" }, + { url = "https://files.pythonhosted.org/packages/c4/ca/8f367cb9fe734c4f6f6400e045593beea2635cd736158f9fabf58ee14e3c/pygame-2.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:20349195326a5e82a16e351ed93465a7845a7e2a9af55b7bc1b2110ea3e344e1", size = 13113753, upload-time = "2024-09-29T14:26:13.751Z" }, + { url = "https://files.pythonhosted.org/packages/83/47/6edf2f890139616b3219be9cfcc8f0cb8f42eb15efd59597927e390538cb/pygame-2.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f3935459109da4bb0b3901da9904f0a3e52028a3332a355d298b1673a334cf21", size = 12378146, upload-time = "2024-09-29T14:26:22.456Z" }, + { url = "https://files.pythonhosted.org/packages/00/9e/0d8aa8cf93db2d2ee38ebaf1c7b61d0df36ded27eb726221719c150c673d/pygame-2.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c31dbdb5d0217f32764797d21c2752e258e5fb7e895326538d82b5f75a0cd856", size = 13611760, upload-time = "2024-09-29T11:10:47.317Z" }, + { url = "https://files.pythonhosted.org/packages/d7/9e/d06adaa5cc65876bcd7a24f59f67e07f7e4194e6298130024ed3fb22c456/pygame-2.6.1-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:173badf82fa198e6888017bea40f511cb28e69ecdd5a72b214e81e4dcd66c3b1", size = 14298054, upload-time = "2024-09-29T11:39:53.891Z" }, + { url = "https://files.pythonhosted.org/packages/7a/a1/9ae2852ebd3a7cc7d9ae7ff7919ab983e4a5c1b7a14e840732f23b2b48f6/pygame-2.6.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce8cc108b92de9b149b344ad2e25eedbe773af0dc41dfb24d1f07f679b558c60", size = 13977107, upload-time = "2024-09-29T11:39:56.831Z" }, + { url = "https://files.pythonhosted.org/packages/31/df/6788fd2e9a864d0496a77670e44a7c012184b7a5382866ab0e60c55c0f28/pygame-2.6.1-cp311-cp311-win32.whl", hash = "sha256:811e7b925146d8149d79193652cbb83e0eca0aae66476b1cb310f0f4226b8b5c", size = 10250863, upload-time = "2024-09-29T11:44:48.199Z" }, + { url = "https://files.pythonhosted.org/packages/d2/55/ca3eb851aeef4f6f2e98a360c201f0d00bd1ba2eb98e2c7850d80aabc526/pygame-2.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:91476902426facd4bb0dad4dc3b2573bc82c95c71b135e0daaea072ed528d299", size = 10622016, upload-time = "2024-09-29T12:17:01.545Z" }, + { url = "https://files.pythonhosted.org/packages/92/16/2c602c332f45ff9526d61f6bd764db5096ff9035433e2172e2d2cadae8db/pygame-2.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:4ee7f2771f588c966fa2fa8b829be26698c9b4836f82ede5e4edc1a68594942e", size = 13118279, upload-time = "2024-09-29T14:26:30.427Z" }, + { url = "https://files.pythonhosted.org/packages/cd/53/77ccbc384b251c6e34bfd2e734c638233922449a7844e3c7a11ef91cee39/pygame-2.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c8040ea2ab18c6b255af706ec01355c8a6b08dc48d77fd4ee783f8fc46a843bf", size = 12384524, upload-time = "2024-09-29T14:26:49.996Z" }, + { url = "https://files.pythonhosted.org/packages/06/be/3ed337583f010696c3b3435e89a74fb29d0c74d0931e8f33c0a4246307a9/pygame-2.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c47a6938de93fa610accd4969e638c2aebcb29b2fca518a84c3a39d91ab47116", size = 13587123, upload-time = "2024-09-29T11:10:50.072Z" }, + { url = "https://files.pythonhosted.org/packages/fd/ca/b015586a450db59313535662991b34d24c1f0c0dc149cc5f496573900f4e/pygame-2.6.1-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:33006f784e1c7d7e466fcb61d5489da59cc5f7eb098712f792a225df1d4e229d", size = 14275532, upload-time = "2024-09-29T11:39:59.356Z" }, + { url = "https://files.pythonhosted.org/packages/b9/f2/d31e6ad42d657af07be2ffd779190353f759a07b51232b9e1d724f2cda46/pygame-2.6.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1206125f14cae22c44565c9d333607f1d9f59487b1f1432945dfc809aeaa3e88", size = 13952653, upload-time = "2024-09-29T11:40:01.781Z" }, + { url = "https://files.pythonhosted.org/packages/f3/42/8ea2a6979e6fa971702fece1747e862e2256d4a8558fe0da6364dd946c53/pygame-2.6.1-cp312-cp312-win32.whl", hash = "sha256:84fc4054e25262140d09d39e094f6880d730199710829902f0d8ceae0213379e", size = 10252421, upload-time = "2024-09-29T11:14:26.877Z" }, + { url = "https://files.pythonhosted.org/packages/5f/90/7d766d54bb95939725e9a9361f9c06b0cfbe3fe100aa35400f0a461a278a/pygame-2.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:3a9e7396be0d9633831c3f8d5d82dd63ba373ad65599628294b7a4f8a5a01a65", size = 10624591, upload-time = "2024-09-29T11:52:54.489Z" }, + { url = "https://files.pythonhosted.org/packages/e1/91/718acf3e2a9d08a6ddcc96bd02a6f63c99ee7ba14afeaff2a51c987df0b9/pygame-2.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ae6039f3a55d800db80e8010f387557b528d34d534435e0871326804df2a62f2", size = 13090765, upload-time = "2024-09-29T14:27:02.377Z" }, + { url = "https://files.pythonhosted.org/packages/0e/c6/9cb315de851a7682d9c7568a41ea042ee98d668cb8deadc1dafcab6116f0/pygame-2.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2a3a1288e2e9b1e5834e425bedd5ba01a3cd4902b5c2bff8ed4a740ccfe98171", size = 12381704, upload-time = "2024-09-29T14:27:10.228Z" }, + { url = "https://files.pythonhosted.org/packages/9f/8f/617a1196e31ae3b46be6949fbaa95b8c93ce15e0544266198c2266cc1b4d/pygame-2.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27eb17e3dc9640e4b4683074f1890e2e879827447770470c2aba9f125f74510b", size = 13581091, upload-time = "2024-09-29T11:30:27.653Z" }, + { url = "https://files.pythonhosted.org/packages/3b/87/2851a564e40a2dad353f1c6e143465d445dab18a95281f9ea458b94f3608/pygame-2.6.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c1623180e70a03c4a734deb9bac50fc9c82942ae84a3a220779062128e75f3b", size = 14273844, upload-time = "2024-09-29T11:40:04.138Z" }, + { url = "https://files.pythonhosted.org/packages/85/b5/aa23aa2e70bcba42c989c02e7228273c30f3b44b9b264abb93eaeff43ad7/pygame-2.6.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef07c0103d79492c21fced9ad68c11c32efa6801ca1920ebfd0f15fb46c78b1c", size = 13951197, upload-time = "2024-09-29T11:40:06.785Z" }, + { url = "https://files.pythonhosted.org/packages/a6/06/29e939b34d3f1354738c7d201c51c250ad7abefefaf6f8332d962ff67c4b/pygame-2.6.1-cp313-cp313-win32.whl", hash = "sha256:3acd8c009317190c2bfd81db681ecef47d5eb108c2151d09596d9c7ea9df5c0e", size = 10249309, upload-time = "2024-09-29T11:10:23.329Z" }, + { url = "https://files.pythonhosted.org/packages/7e/11/17f7f319ca91824b86557e9303e3b7a71991ef17fd45286bf47d7f0a38e6/pygame-2.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:813af4fba5d0b2cb8e58f5d95f7910295c34067dcc290d34f1be59c48bd1ea6a", size = 10620084, upload-time = "2024-09-29T11:48:51.587Z" }, +] + +[[package]] +name = "pygments" +version = "2.20.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/b2/bc9c9196916376152d655522fdcebac55e66de6603a76a02bca1b6414f6c/pygments-2.20.0.tar.gz", hash = "sha256:6757cd03768053ff99f3039c1a36d6c0aa0b263438fcab17520b30a303a82b5f", size = 4955991, upload-time = "2026-03-29T13:29:33.898Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/7e/a72dd26f3b0f4f2bf1dd8923c85f7ceb43172af56d63c7383eb62b332364/pygments-2.20.0-py3-none-any.whl", hash = "sha256:81a9e26dd42fd28a23a2d169d86d7ac03b46e2f8b59ed4698fb4785f946d0176", size = 1231151, upload-time = "2026-03-29T13:29:30.038Z" }, +] + +[[package]] +name = "pylint" +version = "4.0.5" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "astroid" }, + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "dill" }, + { name = "isort" }, + { name = "mccabe" }, + { name = "platformdirs" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, + { name = "tomlkit" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/e4/b6/74d9a8a68b8067efce8d07707fe6a236324ee1e7808d2eb3646ec8517c7d/pylint-4.0.5.tar.gz", hash = "sha256:8cd6a618df75deb013bd7eb98327a95f02a6fb839205a6bbf5456ef96afb317c", size = 1572474, upload-time = "2026-02-20T09:07:33.621Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d5/6f/9ac2548e290764781f9e7e2aaf0685b086379dabfb29ca38536985471eaf/pylint-4.0.5-py3-none-any.whl", hash = "sha256:00f51c9b14a3b3ae08cff6b2cdd43f28165c78b165b628692e428fb1f8dc2cf2", size = 536694, upload-time = "2026-02-20T09:07:31.028Z" }, +] + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f3/91/9c6ee907786a473bf81c5f53cf703ba0957b23ab84c264080fb5a450416f/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc", size = 6851574, upload-time = "2026-01-21T03:57:59.36Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/10/bd/c038d7cc38edc1aa5bf91ab8068b63d4308c66c4c8bb3cbba7dfbc049f9c/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d", size = 122781, upload-time = "2026-01-21T03:57:55.912Z" }, +] + +[[package]] +name = "pytest" +version = "9.0.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "exceptiongroup", marker = "python_full_version < '3.11'" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, + { name = "tomli", marker = "python_full_version < '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/d4/24/a372aaf5c9b7208e7112038812994107bc65a84cd00e0354a88c2c77a617/pytest-9.0.3-py3-none-any.whl", hash = "sha256:2c5efc453d45394fdd706ade797c0a81091eccd1d6e4bccfcd476e2b8e0ab5d9", size = 375249, upload-time = "2026-04-07T17:16:16.13Z" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/a0/39350dd17dd6d6c6507025c0e53aef67a9293a6d37d3511f23ea510d5800/pyyaml-6.0.3-cp310-cp310-macosx_10_13_x86_64.whl", hash = "sha256:214ed4befebe12df36bcc8bc2b64b396ca31be9304b8f59e25c11cf94a4c033b", size = 184227, upload-time = "2025-09-25T21:31:46.04Z" }, + { url = "https://files.pythonhosted.org/packages/05/14/52d505b5c59ce73244f59c7a50ecf47093ce4765f116cdb98286a71eeca2/pyyaml-6.0.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02ea2dfa234451bbb8772601d7b8e426c2bfa197136796224e50e35a78777956", size = 174019, upload-time = "2025-09-25T21:31:47.706Z" }, + { url = "https://files.pythonhosted.org/packages/43/f7/0e6a5ae5599c838c696adb4e6330a59f463265bfa1e116cfd1fbb0abaaae/pyyaml-6.0.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b30236e45cf30d2b8e7b3e85881719e98507abed1011bf463a8fa23e9c3e98a8", size = 740646, upload-time = "2025-09-25T21:31:49.21Z" }, + { url = "https://files.pythonhosted.org/packages/2f/3a/61b9db1d28f00f8fd0ae760459a5c4bf1b941baf714e207b6eb0657d2578/pyyaml-6.0.3-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:66291b10affd76d76f54fad28e22e51719ef9ba22b29e1d7d03d6777a9174198", size = 840793, upload-time = "2025-09-25T21:31:50.735Z" }, + { url = "https://files.pythonhosted.org/packages/7a/1e/7acc4f0e74c4b3d9531e24739e0ab832a5edf40e64fbae1a9c01941cabd7/pyyaml-6.0.3-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c7708761fccb9397fe64bbc0395abcae8c4bf7b0eac081e12b809bf47700d0b", size = 770293, upload-time = "2025-09-25T21:31:51.828Z" }, + { url = "https://files.pythonhosted.org/packages/8b/ef/abd085f06853af0cd59fa5f913d61a8eab65d7639ff2a658d18a25d6a89d/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:418cf3f2111bc80e0933b2cd8cd04f286338bb88bdc7bc8e6dd775ebde60b5e0", size = 732872, upload-time = "2025-09-25T21:31:53.282Z" }, + { url = "https://files.pythonhosted.org/packages/1f/15/2bc9c8faf6450a8b3c9fc5448ed869c599c0a74ba2669772b1f3a0040180/pyyaml-6.0.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5e0b74767e5f8c593e8c9b5912019159ed0533c70051e9cce3e8b6aa699fcd69", size = 758828, upload-time = "2025-09-25T21:31:54.807Z" }, + { url = "https://files.pythonhosted.org/packages/a3/00/531e92e88c00f4333ce359e50c19b8d1de9fe8d581b1534e35ccfbc5f393/pyyaml-6.0.3-cp310-cp310-win32.whl", hash = "sha256:28c8d926f98f432f88adc23edf2e6d4921ac26fb084b028c733d01868d19007e", size = 142415, upload-time = "2025-09-25T21:31:55.885Z" }, + { url = "https://files.pythonhosted.org/packages/2a/fa/926c003379b19fca39dd4634818b00dec6c62d87faf628d1394e137354d4/pyyaml-6.0.3-cp310-cp310-win_amd64.whl", hash = "sha256:bdb2c67c6c1390b63c6ff89f210c8fd09d9a1217a465701eac7316313c915e4c", size = 158561, upload-time = "2025-09-25T21:31:57.406Z" }, + { url = "https://files.pythonhosted.org/packages/6d/16/a95b6757765b7b031c9374925bb718d55e0a9ba8a1b6a12d25962ea44347/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e", size = 185826, upload-time = "2025-09-25T21:31:58.655Z" }, + { url = "https://files.pythonhosted.org/packages/16/19/13de8e4377ed53079ee996e1ab0a9c33ec2faf808a4647b7b4c0d46dd239/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824", size = 175577, upload-time = "2025-09-25T21:32:00.088Z" }, + { url = "https://files.pythonhosted.org/packages/0c/62/d2eb46264d4b157dae1275b573017abec435397aa59cbcdab6fc978a8af4/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c", size = 775556, upload-time = "2025-09-25T21:32:01.31Z" }, + { url = "https://files.pythonhosted.org/packages/10/cb/16c3f2cf3266edd25aaa00d6c4350381c8b012ed6f5276675b9eba8d9ff4/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00", size = 882114, upload-time = "2025-09-25T21:32:03.376Z" }, + { url = "https://files.pythonhosted.org/packages/71/60/917329f640924b18ff085ab889a11c763e0b573da888e8404ff486657602/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d", size = 806638, upload-time = "2025-09-25T21:32:04.553Z" }, + { url = "https://files.pythonhosted.org/packages/dd/6f/529b0f316a9fd167281a6c3826b5583e6192dba792dd55e3203d3f8e655a/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a", size = 767463, upload-time = "2025-09-25T21:32:06.152Z" }, + { url = "https://files.pythonhosted.org/packages/f2/6a/b627b4e0c1dd03718543519ffb2f1deea4a1e6d42fbab8021936a4d22589/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4", size = 794986, upload-time = "2025-09-25T21:32:07.367Z" }, + { url = "https://files.pythonhosted.org/packages/45/91/47a6e1c42d9ee337c4839208f30d9f09caa9f720ec7582917b264defc875/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b", size = 142543, upload-time = "2025-09-25T21:32:08.95Z" }, + { url = "https://files.pythonhosted.org/packages/da/e3/ea007450a105ae919a72393cb06f122f288ef60bba2dc64b26e2646fa315/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf", size = 158763, upload-time = "2025-09-25T21:32:09.96Z" }, + { url = "https://files.pythonhosted.org/packages/d1/33/422b98d2195232ca1826284a76852ad5a86fe23e31b009c9886b2d0fb8b2/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196", size = 182063, upload-time = "2025-09-25T21:32:11.445Z" }, + { url = "https://files.pythonhosted.org/packages/89/a0/6cf41a19a1f2f3feab0e9c0b74134aa2ce6849093d5517a0c550fe37a648/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0", size = 173973, upload-time = "2025-09-25T21:32:12.492Z" }, + { url = "https://files.pythonhosted.org/packages/ed/23/7a778b6bd0b9a8039df8b1b1d80e2e2ad78aa04171592c8a5c43a56a6af4/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28", size = 775116, upload-time = "2025-09-25T21:32:13.652Z" }, + { url = "https://files.pythonhosted.org/packages/65/30/d7353c338e12baef4ecc1b09e877c1970bd3382789c159b4f89d6a70dc09/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c", size = 844011, upload-time = "2025-09-25T21:32:15.21Z" }, + { url = "https://files.pythonhosted.org/packages/8b/9d/b3589d3877982d4f2329302ef98a8026e7f4443c765c46cfecc8858c6b4b/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc", size = 807870, upload-time = "2025-09-25T21:32:16.431Z" }, + { url = "https://files.pythonhosted.org/packages/05/c0/b3be26a015601b822b97d9149ff8cb5ead58c66f981e04fedf4e762f4bd4/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e", size = 761089, upload-time = "2025-09-25T21:32:17.56Z" }, + { url = "https://files.pythonhosted.org/packages/be/8e/98435a21d1d4b46590d5459a22d88128103f8da4c2d4cb8f14f2a96504e1/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea", size = 790181, upload-time = "2025-09-25T21:32:18.834Z" }, + { url = "https://files.pythonhosted.org/packages/74/93/7baea19427dcfbe1e5a372d81473250b379f04b1bd3c4c5ff825e2327202/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5", size = 137658, upload-time = "2025-09-25T21:32:20.209Z" }, + { url = "https://files.pythonhosted.org/packages/86/bf/899e81e4cce32febab4fb42bb97dcdf66bc135272882d1987881a4b519e9/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b", size = 154003, upload-time = "2025-09-25T21:32:21.167Z" }, + { url = "https://files.pythonhosted.org/packages/1a/08/67bd04656199bbb51dbed1439b7f27601dfb576fb864099c7ef0c3e55531/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd", size = 140344, upload-time = "2025-09-25T21:32:22.617Z" }, + { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" }, + { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" }, + { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" }, + { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" }, + { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" }, + { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" }, + { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" }, + { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" }, + { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" }, + { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" }, + { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" }, + { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" }, + { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" }, + { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" }, + { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" }, + { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" }, + { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" }, + { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" }, + { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" }, + { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" }, + { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" }, + { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" }, + { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" }, + { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" }, + { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" }, + { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" }, + { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" }, + { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/67/b9/52aa9ec2867528b54f1e60846728d8b4d84726630874fee3a91e66c7df81/pyzmq-27.1.0-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:508e23ec9bc44c0005c4946ea013d9317ae00ac67778bd47519fdf5a0e930ff4", size = 1329850, upload-time = "2025-09-08T23:07:26.274Z" }, + { url = "https://files.pythonhosted.org/packages/99/64/5653e7b7425b169f994835a2b2abf9486264401fdef18df91ddae47ce2cc/pyzmq-27.1.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:507b6f430bdcf0ee48c0d30e734ea89ce5567fd7b8a0f0044a369c176aa44556", size = 906380, upload-time = "2025-09-08T23:07:29.78Z" }, + { url = "https://files.pythonhosted.org/packages/73/78/7d713284dbe022f6440e391bd1f3c48d9185673878034cfb3939cdf333b2/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bf7b38f9fd7b81cb6d9391b2946382c8237fd814075c6aa9c3b746d53076023b", size = 666421, upload-time = "2025-09-08T23:07:31.263Z" }, + { url = "https://files.pythonhosted.org/packages/30/76/8f099f9d6482450428b17c4d6b241281af7ce6a9de8149ca8c1c649f6792/pyzmq-27.1.0-cp310-cp310-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:03ff0b279b40d687691a6217c12242ee71f0fba28bf8626ff50e3ef0f4410e1e", size = 854149, upload-time = "2025-09-08T23:07:33.17Z" }, + { url = "https://files.pythonhosted.org/packages/59/f0/37fbfff06c68016019043897e4c969ceab18bde46cd2aca89821fcf4fb2e/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:677e744fee605753eac48198b15a2124016c009a11056f93807000ab11ce6526", size = 1655070, upload-time = "2025-09-08T23:07:35.205Z" }, + { url = "https://files.pythonhosted.org/packages/47/14/7254be73f7a8edc3587609554fcaa7bfd30649bf89cd260e4487ca70fdaa/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dd2fec2b13137416a1c5648b7009499bcc8fea78154cd888855fa32514f3dad1", size = 2033441, upload-time = "2025-09-08T23:07:37.432Z" }, + { url = "https://files.pythonhosted.org/packages/22/dc/49f2be26c6f86f347e796a4d99b19167fc94503f0af3fd010ad262158822/pyzmq-27.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:08e90bb4b57603b84eab1d0ca05b3bbb10f60c1839dc471fc1c9e1507bef3386", size = 1891529, upload-time = "2025-09-08T23:07:39.047Z" }, + { url = "https://files.pythonhosted.org/packages/a3/3e/154fb963ae25be70c0064ce97776c937ecc7d8b0259f22858154a9999769/pyzmq-27.1.0-cp310-cp310-win32.whl", hash = "sha256:a5b42d7a0658b515319148875fcb782bbf118dd41c671b62dae33666c2213bda", size = 567276, upload-time = "2025-09-08T23:07:40.695Z" }, + { url = "https://files.pythonhosted.org/packages/62/b2/f4ab56c8c595abcb26b2be5fd9fa9e6899c1e5ad54964e93ae8bb35482be/pyzmq-27.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:c0bb87227430ee3aefcc0ade2088100e528d5d3298a0a715a64f3d04c60ba02f", size = 632208, upload-time = "2025-09-08T23:07:42.298Z" }, + { url = "https://files.pythonhosted.org/packages/3b/e3/be2cc7ab8332bdac0522fdb64c17b1b6241a795bee02e0196636ec5beb79/pyzmq-27.1.0-cp310-cp310-win_arm64.whl", hash = "sha256:9a916f76c2ab8d045b19f2286851a38e9ac94ea91faf65bd64735924522a8b32", size = 559766, upload-time = "2025-09-08T23:07:43.869Z" }, + { url = "https://files.pythonhosted.org/packages/06/5d/305323ba86b284e6fcb0d842d6adaa2999035f70f8c38a9b6d21ad28c3d4/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86", size = 1333328, upload-time = "2025-09-08T23:07:45.946Z" }, + { url = "https://files.pythonhosted.org/packages/bd/a0/fc7e78a23748ad5443ac3275943457e8452da67fda347e05260261108cbc/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581", size = 908803, upload-time = "2025-09-08T23:07:47.551Z" }, + { url = "https://files.pythonhosted.org/packages/7e/22/37d15eb05f3bdfa4abea6f6d96eb3bb58585fbd3e4e0ded4e743bc650c97/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f", size = 668836, upload-time = "2025-09-08T23:07:49.436Z" }, + { url = "https://files.pythonhosted.org/packages/b1/c4/2a6fe5111a01005fc7af3878259ce17684fabb8852815eda6225620f3c59/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e", size = 857038, upload-time = "2025-09-08T23:07:51.234Z" }, + { url = "https://files.pythonhosted.org/packages/cb/eb/bfdcb41d0db9cd233d6fb22dc131583774135505ada800ebf14dfb0a7c40/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e", size = 1657531, upload-time = "2025-09-08T23:07:52.795Z" }, + { url = "https://files.pythonhosted.org/packages/ab/21/e3180ca269ed4a0de5c34417dfe71a8ae80421198be83ee619a8a485b0c7/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2", size = 2034786, upload-time = "2025-09-08T23:07:55.047Z" }, + { url = "https://files.pythonhosted.org/packages/3b/b1/5e21d0b517434b7f33588ff76c177c5a167858cc38ef740608898cd329f2/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394", size = 1894220, upload-time = "2025-09-08T23:07:57.172Z" }, + { url = "https://files.pythonhosted.org/packages/03/f2/44913a6ff6941905efc24a1acf3d3cb6146b636c546c7406c38c49c403d4/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f", size = 567155, upload-time = "2025-09-08T23:07:59.05Z" }, + { url = "https://files.pythonhosted.org/packages/23/6d/d8d92a0eb270a925c9b4dd039c0b4dc10abc2fcbc48331788824ef113935/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97", size = 633428, upload-time = "2025-09-08T23:08:00.663Z" }, + { url = "https://files.pythonhosted.org/packages/ae/14/01afebc96c5abbbd713ecfc7469cfb1bc801c819a74ed5c9fad9a48801cb/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07", size = 559497, upload-time = "2025-09-08T23:08:02.15Z" }, + { url = "https://files.pythonhosted.org/packages/92/e7/038aab64a946d535901103da16b953c8c9cc9c961dadcbf3609ed6428d23/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc", size = 1306279, upload-time = "2025-09-08T23:08:03.807Z" }, + { url = "https://files.pythonhosted.org/packages/e8/5e/c3c49fdd0f535ef45eefcc16934648e9e59dace4a37ee88fc53f6cd8e641/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113", size = 895645, upload-time = "2025-09-08T23:08:05.301Z" }, + { url = "https://files.pythonhosted.org/packages/f8/e5/b0b2504cb4e903a74dcf1ebae157f9e20ebb6ea76095f6cfffea28c42ecd/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233", size = 652574, upload-time = "2025-09-08T23:08:06.828Z" }, + { url = "https://files.pythonhosted.org/packages/f8/9b/c108cdb55560eaf253f0cbdb61b29971e9fb34d9c3499b0e96e4e60ed8a5/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31", size = 840995, upload-time = "2025-09-08T23:08:08.396Z" }, + { url = "https://files.pythonhosted.org/packages/c2/bb/b79798ca177b9eb0825b4c9998c6af8cd2a7f15a6a1a4272c1d1a21d382f/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28", size = 1642070, upload-time = "2025-09-08T23:08:09.989Z" }, + { url = "https://files.pythonhosted.org/packages/9c/80/2df2e7977c4ede24c79ae39dcef3899bfc5f34d1ca7a5b24f182c9b7a9ca/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856", size = 2021121, upload-time = "2025-09-08T23:08:11.907Z" }, + { url = "https://files.pythonhosted.org/packages/46/bd/2d45ad24f5f5ae7e8d01525eb76786fa7557136555cac7d929880519e33a/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496", size = 1878550, upload-time = "2025-09-08T23:08:13.513Z" }, + { url = "https://files.pythonhosted.org/packages/e6/2f/104c0a3c778d7c2ab8190e9db4f62f0b6957b53c9d87db77c284b69f33ea/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd", size = 559184, upload-time = "2025-09-08T23:08:15.163Z" }, + { url = "https://files.pythonhosted.org/packages/fc/7f/a21b20d577e4100c6a41795842028235998a643b1ad406a6d4163ea8f53e/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf", size = 619480, upload-time = "2025-09-08T23:08:17.192Z" }, + { url = "https://files.pythonhosted.org/packages/78/c2/c012beae5f76b72f007a9e91ee9401cb88c51d0f83c6257a03e785c81cc2/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f", size = 552993, upload-time = "2025-09-08T23:08:18.926Z" }, + { url = "https://files.pythonhosted.org/packages/60/cb/84a13459c51da6cec1b7b1dc1a47e6db6da50b77ad7fd9c145842750a011/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5", size = 1122436, upload-time = "2025-09-08T23:08:20.801Z" }, + { url = "https://files.pythonhosted.org/packages/dc/b6/94414759a69a26c3dd674570a81813c46a078767d931a6c70ad29fc585cb/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6", size = 1156301, upload-time = "2025-09-08T23:08:22.47Z" }, + { url = "https://files.pythonhosted.org/packages/a5/ad/15906493fd40c316377fd8a8f6b1f93104f97a752667763c9b9c1b71d42d/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7", size = 1341197, upload-time = "2025-09-08T23:08:24.286Z" }, + { url = "https://files.pythonhosted.org/packages/14/1d/d343f3ce13db53a54cb8946594e567410b2125394dafcc0268d8dda027e0/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05", size = 897275, upload-time = "2025-09-08T23:08:26.063Z" }, + { url = "https://files.pythonhosted.org/packages/69/2d/d83dd6d7ca929a2fc67d2c3005415cdf322af7751d773524809f9e585129/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9", size = 660469, upload-time = "2025-09-08T23:08:27.623Z" }, + { url = "https://files.pythonhosted.org/packages/3e/cd/9822a7af117f4bc0f1952dbe9ef8358eb50a24928efd5edf54210b850259/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128", size = 847961, upload-time = "2025-09-08T23:08:29.672Z" }, + { url = "https://files.pythonhosted.org/packages/9a/12/f003e824a19ed73be15542f172fd0ec4ad0b60cf37436652c93b9df7c585/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39", size = 1650282, upload-time = "2025-09-08T23:08:31.349Z" }, + { url = "https://files.pythonhosted.org/packages/d5/4a/e82d788ed58e9a23995cee70dbc20c9aded3d13a92d30d57ec2291f1e8a3/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97", size = 2024468, upload-time = "2025-09-08T23:08:33.543Z" }, + { url = "https://files.pythonhosted.org/packages/d9/94/2da0a60841f757481e402b34bf4c8bf57fa54a5466b965de791b1e6f747d/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db", size = 1885394, upload-time = "2025-09-08T23:08:35.51Z" }, + { url = "https://files.pythonhosted.org/packages/4f/6f/55c10e2e49ad52d080dc24e37adb215e5b0d64990b57598abc2e3f01725b/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c", size = 574964, upload-time = "2025-09-08T23:08:37.178Z" }, + { url = "https://files.pythonhosted.org/packages/87/4d/2534970ba63dd7c522d8ca80fb92777f362c0f321900667c615e2067cb29/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2", size = 641029, upload-time = "2025-09-08T23:08:40.595Z" }, + { url = "https://files.pythonhosted.org/packages/f6/fa/f8aea7a28b0641f31d40dea42d7ef003fded31e184ef47db696bc74cd610/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e", size = 561541, upload-time = "2025-09-08T23:08:42.668Z" }, + { url = "https://files.pythonhosted.org/packages/87/45/19efbb3000956e82d0331bafca5d9ac19ea2857722fa2caacefb6042f39d/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a", size = 1341197, upload-time = "2025-09-08T23:08:44.973Z" }, + { url = "https://files.pythonhosted.org/packages/48/43/d72ccdbf0d73d1343936296665826350cb1e825f92f2db9db3e61c2162a2/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea", size = 897175, upload-time = "2025-09-08T23:08:46.601Z" }, + { url = "https://files.pythonhosted.org/packages/2f/2e/a483f73a10b65a9ef0161e817321d39a770b2acf8bcf3004a28d90d14a94/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96", size = 660427, upload-time = "2025-09-08T23:08:48.187Z" }, + { url = "https://files.pythonhosted.org/packages/f5/d2/5f36552c2d3e5685abe60dfa56f91169f7a2d99bbaf67c5271022ab40863/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d", size = 847929, upload-time = "2025-09-08T23:08:49.76Z" }, + { url = "https://files.pythonhosted.org/packages/c4/2a/404b331f2b7bf3198e9945f75c4c521f0c6a3a23b51f7a4a401b94a13833/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146", size = 1650193, upload-time = "2025-09-08T23:08:51.7Z" }, + { url = "https://files.pythonhosted.org/packages/1c/0b/f4107e33f62a5acf60e3ded67ed33d79b4ce18de432625ce2fc5093d6388/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd", size = 2024388, upload-time = "2025-09-08T23:08:53.393Z" }, + { url = "https://files.pythonhosted.org/packages/0d/01/add31fe76512642fd6e40e3a3bd21f4b47e242c8ba33efb6809e37076d9b/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a", size = 1885316, upload-time = "2025-09-08T23:08:55.702Z" }, + { url = "https://files.pythonhosted.org/packages/c4/59/a5f38970f9bf07cee96128de79590bb354917914a9be11272cfc7ff26af0/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92", size = 587472, upload-time = "2025-09-08T23:08:58.18Z" }, + { url = "https://files.pythonhosted.org/packages/70/d8/78b1bad170f93fcf5e3536e70e8fadac55030002275c9a29e8f5719185de/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0", size = 661401, upload-time = "2025-09-08T23:08:59.802Z" }, + { url = "https://files.pythonhosted.org/packages/81/d6/4bfbb40c9a0b42fc53c7cf442f6385db70b40f74a783130c5d0a5aa62228/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7", size = 575170, upload-time = "2025-09-08T23:09:01.418Z" }, + { url = "https://files.pythonhosted.org/packages/f3/81/a65e71c1552f74dec9dff91d95bafb6e0d33338a8dfefbc88aa562a20c92/pyzmq-27.1.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c17e03cbc9312bee223864f1a2b13a99522e0dc9f7c5df0177cd45210ac286e6", size = 836266, upload-time = "2025-09-08T23:09:40.048Z" }, + { url = "https://files.pythonhosted.org/packages/58/ed/0202ca350f4f2b69faa95c6d931e3c05c3a397c184cacb84cb4f8f42f287/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f328d01128373cb6763823b2b4e7f73bdf767834268c565151eacb3b7a392f90", size = 800206, upload-time = "2025-09-08T23:09:41.902Z" }, + { url = "https://files.pythonhosted.org/packages/47/42/1ff831fa87fe8f0a840ddb399054ca0009605d820e2b44ea43114f5459f4/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c1790386614232e1b3a40a958454bdd42c6d1811837b15ddbb052a032a43f62", size = 567747, upload-time = "2025-09-08T23:09:43.741Z" }, + { url = "https://files.pythonhosted.org/packages/d1/db/5c4d6807434751e3f21231bee98109aa57b9b9b55e058e450d0aef59b70f/pyzmq-27.1.0-pp310-pypy310_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:448f9cb54eb0cee4732b46584f2710c8bc178b0e5371d9e4fc8125201e413a74", size = 747371, upload-time = "2025-09-08T23:09:45.575Z" }, + { url = "https://files.pythonhosted.org/packages/26/af/78ce193dbf03567eb8c0dc30e3df2b9e56f12a670bf7eb20f9fb532c7e8a/pyzmq-27.1.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:05b12f2d32112bf8c95ef2e74ec4f1d4beb01f8b5e703b38537f8849f92cb9ba", size = 544862, upload-time = "2025-09-08T23:09:47.448Z" }, + { url = "https://files.pythonhosted.org/packages/4c/c6/c4dcdecdbaa70969ee1fdced6d7b8f60cfabe64d25361f27ac4665a70620/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066", size = 836265, upload-time = "2025-09-08T23:09:49.376Z" }, + { url = "https://files.pythonhosted.org/packages/3e/79/f38c92eeaeb03a2ccc2ba9866f0439593bb08c5e3b714ac1d553e5c96e25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604", size = 800208, upload-time = "2025-09-08T23:09:51.073Z" }, + { url = "https://files.pythonhosted.org/packages/49/0e/3f0d0d335c6b3abb9b7b723776d0b21fa7f3a6c819a0db6097059aada160/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c", size = 567747, upload-time = "2025-09-08T23:09:52.698Z" }, + { url = "https://files.pythonhosted.org/packages/a1/cf/f2b3784d536250ffd4be70e049f3b60981235d70c6e8ce7e3ef21e1adb25/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271", size = 747371, upload-time = "2025-09-08T23:09:54.563Z" }, + { url = "https://files.pythonhosted.org/packages/01/1b/5dbe84eefc86f48473947e2f41711aded97eecef1231f4558f1f02713c12/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355", size = 544862, upload-time = "2025-09-08T23:09:56.509Z" }, +] + +[[package]] +name = "ruff" +version = "0.15.11" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/e4/8d/192f3d7103816158dfd5ea50d098ef2aec19194e6cbccd4b3485bdb2eb2d/ruff-0.15.11.tar.gz", hash = "sha256:f092b21708bf0e7437ce9ada249dfe688ff9a0954fc94abab05dcea7dcd29c33", size = 4637264, upload-time = "2026-04-16T18:46:26.58Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/02/1e/6aca3427f751295ab011828e15e9bf452200ac74484f1db4be0197b8170b/ruff-0.15.11-py3-none-linux_armv6l.whl", hash = "sha256:e927cfff503135c558eb581a0c9792264aae9507904eb27809cdcff2f2c847b7", size = 10607943, upload-time = "2026-04-16T18:46:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/e7/26/1341c262e74f36d4e84f3d6f4df0ac68cd53331a66bfc5080daa17c84c0b/ruff-0.15.11-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:7a1b5b2938d8f890b76084d4fa843604d787a912541eae85fd7e233398bbb73e", size = 10988592, upload-time = "2026-04-16T18:46:00.742Z" }, + { url = "https://files.pythonhosted.org/packages/03/71/850b1d6ffa9564fbb6740429bad53df1094082fe515c8c1e74b6d8d05f18/ruff-0.15.11-py3-none-macosx_11_0_arm64.whl", hash = "sha256:d4176f3d194afbdaee6e41b9ccb1a2c287dba8700047df474abfbe773825d1cb", size = 10338501, upload-time = "2026-04-16T18:46:03.723Z" }, + { url = "https://files.pythonhosted.org/packages/f2/11/cc1284d3e298c45a817a6aadb6c3e1d70b45c9b36d8d9cce3387b495a03a/ruff-0.15.11-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b17c886fb88203ced3afe7f14e8d5ae96e9d2f4ccc0ee66aa19f2c2675a27e4", size = 10670693, upload-time = "2026-04-16T18:46:41.941Z" }, + { url = "https://files.pythonhosted.org/packages/ce/9e/f8288b034ab72b371513c13f9a41d9ba3effac54e24bfb467b007daee2ca/ruff-0.15.11-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:49fafa220220afe7758a487b048de4c8f9f767f37dfefad46b9dd06759d003eb", size = 10416177, upload-time = "2026-04-16T18:46:21.717Z" }, + { url = "https://files.pythonhosted.org/packages/85/71/504d79abfd3d92532ba6bbe3d1c19fada03e494332a59e37c7c2dabae427/ruff-0.15.11-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2ab8427e74a00d93b8bda1307b1e60970d40f304af38bccb218e056c220120d", size = 11221886, upload-time = "2026-04-16T18:46:15.086Z" }, + { url = "https://files.pythonhosted.org/packages/43/5a/947e6ab7a5ad603d65b474be15a4cbc6d29832db5d762cd142e4e3a74164/ruff-0.15.11-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:195072c0c8e1fc8f940652073df082e37a5d9cb43b4ab1e4d0566ab8977a13b7", size = 12075183, upload-time = "2026-04-16T18:46:07.944Z" }, + { url = "https://files.pythonhosted.org/packages/9f/a1/0b7bb6268775fdd3a0818aee8efd8f5b4e231d24dd4d528ced2534023182/ruff-0.15.11-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a3a0996d486af3920dec930a2e7daed4847dfc12649b537a9335585ada163e9e", size = 11516575, upload-time = "2026-04-16T18:46:31.687Z" }, + { url = "https://files.pythonhosted.org/packages/30/c3/bb5168fc4d233cc06e95f482770d0f3c87945a0cd9f614b90ea8dc2f2833/ruff-0.15.11-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bef2cb556d509259f1fe440bb9cd33c756222cf0a7afe90d15edf0866702431", size = 11306537, upload-time = "2026-04-16T18:46:36.988Z" }, + { url = "https://files.pythonhosted.org/packages/e4/92/4cfae6441f3967317946f3b788136eecf093729b94d6561f963ed810c82e/ruff-0.15.11-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:030d921a836d7d4a12cf6e8d984a88b66094ccb0e0f17ddd55067c331191bf19", size = 11296813, upload-time = "2026-04-16T18:46:24.182Z" }, + { url = "https://files.pythonhosted.org/packages/43/26/972784c5dde8313acde8ac71ba8ac65475b85db4a2352a76c9934361f9bc/ruff-0.15.11-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0e783b599b4577788dbbb66b9addcef87e9a8832f4ce0c19e34bf55543a2f890", size = 10633136, upload-time = "2026-04-16T18:46:39.802Z" }, + { url = "https://files.pythonhosted.org/packages/5b/53/3985a4f185020c2f367f2e08a103032e12564829742a1b417980ce1514a0/ruff-0.15.11-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:ae90592246625ba4a34349d68ec28d4400d75182b71baa196ddb9f82db025ef5", size = 10424701, upload-time = "2026-04-16T18:46:10.381Z" }, + { url = "https://files.pythonhosted.org/packages/d3/57/bf0dfb32241b56c83bb663a826133da4bf17f682ba8c096973065f6e6a68/ruff-0.15.11-py3-none-musllinux_1_2_i686.whl", hash = "sha256:1f111d62e3c983ed20e0ca2e800f8d77433a5b1161947df99a5c2a3fb60514f0", size = 10873887, upload-time = "2026-04-16T18:46:29.157Z" }, + { url = "https://files.pythonhosted.org/packages/02/05/e48076b2a57dc33ee8c7a957296f97c744ca891a8ffb4ffb1aaa3b3f517d/ruff-0.15.11-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:06f483d6646f59eaffba9ae30956370d3a886625f511a3108994000480621d1c", size = 11404316, upload-time = "2026-04-16T18:46:19.462Z" }, + { url = "https://files.pythonhosted.org/packages/88/27/0195d15fe7a897cbcba0904792c4b7c9fdd958456c3a17d2ea6093716a9a/ruff-0.15.11-py3-none-win32.whl", hash = "sha256:476a2aa56b7da0b73a3ee80b6b2f0e19cce544245479adde7baa65466664d5f3", size = 10655535, upload-time = "2026-04-16T18:46:12.47Z" }, + { url = "https://files.pythonhosted.org/packages/3a/5e/c927b325bd4c1d3620211a4b96f47864633199feed60fa936025ab27e090/ruff-0.15.11-py3-none-win_amd64.whl", hash = "sha256:8b6756d88d7e234fb0c98c91511aae3cd519d5e3ed271cae31b20f39cb2a12a3", size = 11779692, upload-time = "2026-04-16T18:46:17.268Z" }, + { url = "https://files.pythonhosted.org/packages/63/b6/aeadee5443e49baa2facd51131159fd6301cc4ccfc1541e4df7b021c37dd/ruff-0.15.11-py3-none-win_arm64.whl", hash = "sha256:063fed18cc1bbe0ee7393957284a6fe8b588c6a406a285af3ee3f46da2391ee4", size = 11032614, upload-time = "2026-04-16T18:46:34.487Z" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f1/7b/ce1eafaf1a76852e2ec9b22edecf1daa58175c090266e9f6c64afcd81d91/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695", size = 24521, upload-time = "2023-09-30T13:58:03.53Z" }, +] + +[[package]] +name = "supersuit" +version = "3.9.3" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "gymnasium" }, + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, + { name = "tinyscaler" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/ba/c5/74e32167c36bef901efa4b6c977711466f1bb1ad83a8fbd4603eee401b2a/supersuit-3.9.3.tar.gz", hash = "sha256:10f5d0ed208ddb92fba767a7889ada9f46894519077527d6af799a7767a13159", size = 34251, upload-time = "2024-08-12T16:01:48.387Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/40/aa/63ba1c60e15334918abf1991ad1584d2dfc5760b352cba5cb98d61e7ef20/SuperSuit-3.9.3-py3-none-any.whl", hash = "sha256:f30ab6fd9fe720ea7fa73d45a96935b6321c4ea1aa45d7997684c09f39aa10de", size = 50175, upload-time = "2024-08-12T16:01:46.149Z" }, +] + +[[package]] +name = "til-environment" +version = "1.4.0a1" +source = { editable = "." } +dependencies = [ + { name = "gymnasium" }, + { name = "imageio", extra = ["ffmpeg"] }, + { name = "mazelib" }, + { name = "omegaconf" }, + { name = "perlin-noise" }, + { name = "pettingzoo" }, + { name = "pygame" }, + { name = "supersuit" }, +] + +[package.dev-dependencies] +dev = [ + { name = "ipykernel" }, + { name = "lefthook" }, + { name = "matplotlib" }, + { name = "pylint" }, + { name = "pytest" }, + { name = "ruff" }, +] + +[package.metadata] +requires-dist = [ + { name = "gymnasium", specifier = "==1.1.1" }, + { name = "imageio", extras = ["ffmpeg"], specifier = ">=2.28" }, + { name = "mazelib", specifier = "==0.9.16" }, + { name = "omegaconf", specifier = ">=2.3.0" }, + { name = "perlin-noise", specifier = ">=1.14" }, + { name = "pettingzoo", specifier = "==1.25.0" }, + { name = "pygame", specifier = ">=2.1.3" }, + { name = "supersuit", specifier = "==3.9.3" }, +] + +[package.metadata.requires-dev] +dev = [ + { name = "ipykernel", specifier = ">=7.2.0" }, + { name = "lefthook", specifier = ">=2.1.6" }, + { name = "matplotlib", specifier = ">=3.10.9" }, + { name = "pylint", specifier = ">=4.0.5" }, + { name = "pytest", specifier = ">=9.0.3" }, + { name = "ruff", specifier = ">=0.15.11" }, +] + +[[package]] +name = "tinyscaler" +version = "1.2.8" +source = { registry = "https://pypi.org/simple" } +dependencies = [ + { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, + { name = "numpy", version = "2.4.4", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, +] +sdist = { url = "https://files.pythonhosted.org/packages/0d/59/6b6495fe9bb3153306a4bd6dd24c78ff74eaf64f90fc6e545ede0574cfbe/tinyscaler-1.2.8.tar.gz", hash = "sha256:0ce3b77562f1db74b2035ccaf62807af043333ce655e71effd6ec85fbf8ded06", size = 156935, upload-time = "2024-08-02T19:25:10.976Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/96/14/0b47fbc882faa2358fc205734bd4b872c84539ef8231bbf1ef2eb5e99506/tinyscaler-1.2.8-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:b69a0414d626ba5d075b93546f37ece0c10f690f7d3ce3f162c2316ac1667511", size = 178487, upload-time = "2024-08-02T19:24:41.372Z" }, + { url = "https://files.pythonhosted.org/packages/b7/b2/3c38f6727b1618160248b6c56486eb006db153c2ca99381251343cd54376/tinyscaler-1.2.8-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb30db6782df95c34b294266876e71fd3d32dd3d33bf4c8ec72d07f570ae7bca", size = 522789, upload-time = "2024-08-02T19:24:43.158Z" }, + { url = "https://files.pythonhosted.org/packages/70/7e/b42030012265686e2f95f2449dd7e40b1e54d92a371f90b11c11bdd8b6c3/tinyscaler-1.2.8-cp310-cp310-win_amd64.whl", hash = "sha256:34d43fad3e09331b7a9259ee11ff4c209c31f00129b3a0c98480f7e43c789c2f", size = 83870, upload-time = "2024-08-02T19:24:44.369Z" }, + { url = "https://files.pythonhosted.org/packages/01/c9/a2dbce5c9ecfaff4887bc0f5ff2288c678e25810801e84ddd737d4c0f3e8/tinyscaler-1.2.8-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:57ad9b0203e984ad140b31f0fe82f8bd82e4c31574461264a9a6e7f7d105eb50", size = 178323, upload-time = "2024-08-02T19:24:46.023Z" }, + { url = "https://files.pythonhosted.org/packages/3b/0e/c52b316dccb2181521a5faca6ef404670e567dddb6f38cbd72175af23d49/tinyscaler-1.2.8-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7dbf9f80ba08918c304261e2f8e3356eccbc925364b706cef2997f0abf0fc91", size = 563254, upload-time = "2024-08-02T19:24:47.904Z" }, + { url = "https://files.pythonhosted.org/packages/21/8f/c064ace9fe32a3968eedd1ae19f079020f0fdd55e811dfd1c7a2b6cc442f/tinyscaler-1.2.8-cp311-cp311-win_amd64.whl", hash = "sha256:93869b729bc2d596e2b2e0803d2f9e0e1a0baced6c96b8c21af178b3061b3fba", size = 83955, upload-time = "2024-08-02T19:24:49.772Z" }, + { url = "https://files.pythonhosted.org/packages/4b/65/06fa456d375b71672affd292dd79f199b21a574eb0501afa142f85133b99/tinyscaler-1.2.8-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:fcafd6a8b7ac8c8eabc560f99f987e3e9c00b32a5f3472b28ee865db9bf264b2", size = 179781, upload-time = "2024-08-02T19:24:52.129Z" }, + { url = "https://files.pythonhosted.org/packages/b7/cf/528a73de4ad128de99bf7cc0e80f236aeeb36fda1e2768a7eb73210a91ff/tinyscaler-1.2.8-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7474fe93740b0aa045e4e2ad60f8df6d5d570c4ea903c6d63ca3868efd8f4e22", size = 563642, upload-time = "2024-08-02T19:24:54.1Z" }, + { url = "https://files.pythonhosted.org/packages/68/d0/0b0abfde6acdf79b41ea685067a52d3e47f3b1fb4a0f4f49d9c6f281a3c7/tinyscaler-1.2.8-cp312-cp312-win_amd64.whl", hash = "sha256:6a7c18d9c082f30193bd23a6eb8ad84d2ee9b224138c8c25a76db96cba71a473", size = 83779, upload-time = "2024-08-02T19:24:56.186Z" }, +] + +[[package]] +name = "tomli" +version = "2.4.1" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/22/de/48c59722572767841493b26183a0d1cc411d54fd759c5607c4590b6563a6/tomli-2.4.1.tar.gz", hash = "sha256:7c7e1a961a0b2f2472c1ac5b69affa0ae1132c39adcb67aba98568702b9cc23f", size = 17543, upload-time = "2026-03-25T20:22:03.828Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/f4/11/db3d5885d8528263d8adc260bb2d28ebf1270b96e98f0e0268d32b8d9900/tomli-2.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f8f0fc26ec2cc2b965b7a3b87cd19c5c6b8c5e5f436b984e85f486d652285c30", size = 154704, upload-time = "2026-03-25T20:21:10.473Z" }, + { url = "https://files.pythonhosted.org/packages/6d/f7/675db52c7e46064a9aa928885a9b20f4124ecb9bc2e1ce74c9106648d202/tomli-2.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4ab97e64ccda8756376892c53a72bd1f964e519c77236368527f758fbc36a53a", size = 149454, upload-time = "2026-03-25T20:21:12.036Z" }, + { url = "https://files.pythonhosted.org/packages/61/71/81c50943cf953efa35bce7646caab3cf457a7d8c030b27cfb40d7235f9ee/tomli-2.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96481a5786729fd470164b47cdb3e0e58062a496f455ee41b4403be77cb5a076", size = 237561, upload-time = "2026-03-25T20:21:13.098Z" }, + { url = "https://files.pythonhosted.org/packages/48/c1/f41d9cb618acccca7df82aaf682f9b49013c9397212cb9f53219e3abac37/tomli-2.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5a881ab208c0baf688221f8cecc5401bd291d67e38a1ac884d6736cbcd8247e9", size = 243824, upload-time = "2026-03-25T20:21:14.569Z" }, + { url = "https://files.pythonhosted.org/packages/22/e4/5a816ecdd1f8ca51fb756ef684b90f2780afc52fc67f987e3c61d800a46d/tomli-2.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:47149d5bd38761ac8be13a84864bf0b7b70bc051806bc3669ab1cbc56216b23c", size = 242227, upload-time = "2026-03-25T20:21:15.712Z" }, + { url = "https://files.pythonhosted.org/packages/6b/49/2b2a0ef529aa6eec245d25f0c703e020a73955ad7edf73e7f54ddc608aa5/tomli-2.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ec9bfaf3ad2df51ace80688143a6a4ebc09a248f6ff781a9945e51937008fcbc", size = 247859, upload-time = "2026-03-25T20:21:17.001Z" }, + { url = "https://files.pythonhosted.org/packages/83/bd/6c1a630eaca337e1e78c5903104f831bda934c426f9231429396ce3c3467/tomli-2.4.1-cp311-cp311-win32.whl", hash = "sha256:ff2983983d34813c1aeb0fa89091e76c3a22889ee83ab27c5eeb45100560c049", size = 97204, upload-time = "2026-03-25T20:21:18.079Z" }, + { url = "https://files.pythonhosted.org/packages/42/59/71461df1a885647e10b6bb7802d0b8e66480c61f3f43079e0dcd315b3954/tomli-2.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:5ee18d9ebdb417e384b58fe414e8d6af9f4e7a0ae761519fb50f721de398dd4e", size = 108084, upload-time = "2026-03-25T20:21:18.978Z" }, + { url = "https://files.pythonhosted.org/packages/b8/83/dceca96142499c069475b790e7913b1044c1a4337e700751f48ed723f883/tomli-2.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:c2541745709bad0264b7d4705ad453b76ccd191e64aa6f0fc66b69a293a45ece", size = 95285, upload-time = "2026-03-25T20:21:20.309Z" }, + { url = "https://files.pythonhosted.org/packages/c1/ba/42f134a3fe2b370f555f44b1d72feebb94debcab01676bf918d0cb70e9aa/tomli-2.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c742f741d58a28940ce01d58f0ab2ea3ced8b12402f162f4d534dfe18ba1cd6a", size = 155924, upload-time = "2026-03-25T20:21:21.626Z" }, + { url = "https://files.pythonhosted.org/packages/dc/c7/62d7a17c26487ade21c5422b646110f2162f1fcc95980ef7f63e73c68f14/tomli-2.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7f86fd587c4ed9dd76f318225e7d9b29cfc5a9d43de44e5754db8d1128487085", size = 150018, upload-time = "2026-03-25T20:21:23.002Z" }, + { url = "https://files.pythonhosted.org/packages/5c/05/79d13d7c15f13bdef410bdd49a6485b1c37d28968314eabee452c22a7fda/tomli-2.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ff18e6a727ee0ab0388507b89d1bc6a22b138d1e2fa56d1ad494586d61d2eae9", size = 244948, upload-time = "2026-03-25T20:21:24.04Z" }, + { url = "https://files.pythonhosted.org/packages/10/90/d62ce007a1c80d0b2c93e02cab211224756240884751b94ca72df8a875ca/tomli-2.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:136443dbd7e1dee43c68ac2694fde36b2849865fa258d39bf822c10e8068eac5", size = 253341, upload-time = "2026-03-25T20:21:25.177Z" }, + { url = "https://files.pythonhosted.org/packages/1a/7e/caf6496d60152ad4ed09282c1885cca4eea150bfd007da84aea07bcc0a3e/tomli-2.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5e262d41726bc187e69af7825504c933b6794dc3fbd5945e41a79bb14c31f585", size = 248159, upload-time = "2026-03-25T20:21:26.364Z" }, + { url = "https://files.pythonhosted.org/packages/99/e7/c6f69c3120de34bbd882c6fba7975f3d7a746e9218e56ab46a1bc4b42552/tomli-2.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5cb41aa38891e073ee49d55fbc7839cfdb2bc0e600add13874d048c94aadddd1", size = 253290, upload-time = "2026-03-25T20:21:27.46Z" }, + { url = "https://files.pythonhosted.org/packages/d6/2f/4a3c322f22c5c66c4b836ec58211641a4067364f5dcdd7b974b4c5da300c/tomli-2.4.1-cp312-cp312-win32.whl", hash = "sha256:da25dc3563bff5965356133435b757a795a17b17d01dbc0f42fb32447ddfd917", size = 98141, upload-time = "2026-03-25T20:21:28.492Z" }, + { url = "https://files.pythonhosted.org/packages/24/22/4daacd05391b92c55759d55eaee21e1dfaea86ce5c571f10083360adf534/tomli-2.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:52c8ef851d9a240f11a88c003eacb03c31fc1c9c4ec64a99a0f922b93874fda9", size = 108847, upload-time = "2026-03-25T20:21:29.386Z" }, + { url = "https://files.pythonhosted.org/packages/68/fd/70e768887666ddd9e9f5d85129e84910f2db2796f9096aa02b721a53098d/tomli-2.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:f758f1b9299d059cc3f6546ae2af89670cb1c4d48ea29c3cacc4fe7de3058257", size = 95088, upload-time = "2026-03-25T20:21:30.677Z" }, + { url = "https://files.pythonhosted.org/packages/07/06/b823a7e818c756d9a7123ba2cda7d07bc2dd32835648d1a7b7b7a05d848d/tomli-2.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:36d2bd2ad5fb9eaddba5226aa02c8ec3fa4f192631e347b3ed28186d43be6b54", size = 155866, upload-time = "2026-03-25T20:21:31.65Z" }, + { url = "https://files.pythonhosted.org/packages/14/6f/12645cf7f08e1a20c7eb8c297c6f11d31c1b50f316a7e7e1e1de6e2e7b7e/tomli-2.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:eb0dc4e38e6a1fd579e5d50369aa2e10acfc9cace504579b2faabb478e76941a", size = 149887, upload-time = "2026-03-25T20:21:33.028Z" }, + { url = "https://files.pythonhosted.org/packages/5c/e0/90637574e5e7212c09099c67ad349b04ec4d6020324539297b634a0192b0/tomli-2.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c7f2c7f2b9ca6bdeef8f0fa897f8e05085923eb091721675170254cbc5b02897", size = 243704, upload-time = "2026-03-25T20:21:34.51Z" }, + { url = "https://files.pythonhosted.org/packages/10/8f/d3ddb16c5a4befdf31a23307f72828686ab2096f068eaf56631e136c1fdd/tomli-2.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f3c6818a1a86dd6dca7ddcaaf76947d5ba31aecc28cb1b67009a5877c9a64f3f", size = 251628, upload-time = "2026-03-25T20:21:36.012Z" }, + { url = "https://files.pythonhosted.org/packages/e3/f1/dbeeb9116715abee2485bf0a12d07a8f31af94d71608c171c45f64c0469d/tomli-2.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d312ef37c91508b0ab2cee7da26ec0b3ed2f03ce12bd87a588d771ae15dcf82d", size = 247180, upload-time = "2026-03-25T20:21:37.136Z" }, + { url = "https://files.pythonhosted.org/packages/d3/74/16336ffd19ed4da28a70959f92f506233bd7cfc2332b20bdb01591e8b1d1/tomli-2.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51529d40e3ca50046d7606fa99ce3956a617f9b36380da3b7f0dd3dd28e68cb5", size = 251674, upload-time = "2026-03-25T20:21:38.298Z" }, + { url = "https://files.pythonhosted.org/packages/16/f9/229fa3434c590ddf6c0aa9af64d3af4b752540686cace29e6281e3458469/tomli-2.4.1-cp313-cp313-win32.whl", hash = "sha256:2190f2e9dd7508d2a90ded5ed369255980a1bcdd58e52f7fe24b8162bf9fedbd", size = 97976, upload-time = "2026-03-25T20:21:39.316Z" }, + { url = "https://files.pythonhosted.org/packages/6a/1e/71dfd96bcc1c775420cb8befe7a9d35f2e5b1309798f009dca17b7708c1e/tomli-2.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:8d65a2fbf9d2f8352685bc1364177ee3923d6baf5e7f43ea4959d7d8bc326a36", size = 108755, upload-time = "2026-03-25T20:21:40.248Z" }, + { url = "https://files.pythonhosted.org/packages/83/7a/d34f422a021d62420b78f5c538e5b102f62bea616d1d75a13f0a88acb04a/tomli-2.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:4b605484e43cdc43f0954ddae319fb75f04cc10dd80d830540060ee7cd0243cd", size = 95265, upload-time = "2026-03-25T20:21:41.219Z" }, + { url = "https://files.pythonhosted.org/packages/3c/fb/9a5c8d27dbab540869f7c1f8eb0abb3244189ce780ba9cd73f3770662072/tomli-2.4.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:fd0409a3653af6c147209d267a0e4243f0ae46b011aa978b1080359fddc9b6cf", size = 155726, upload-time = "2026-03-25T20:21:42.23Z" }, + { url = "https://files.pythonhosted.org/packages/62/05/d2f816630cc771ad836af54f5001f47a6f611d2d39535364f148b6a92d6b/tomli-2.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a120733b01c45e9a0c34aeef92bf0cf1d56cfe81ed9d47d562f9ed591a9828ac", size = 149859, upload-time = "2026-03-25T20:21:43.386Z" }, + { url = "https://files.pythonhosted.org/packages/ce/48/66341bdb858ad9bd0ceab5a86f90eddab127cf8b046418009f2125630ecb/tomli-2.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:559db847dc486944896521f68d8190be1c9e719fced785720d2216fe7022b662", size = 244713, upload-time = "2026-03-25T20:21:44.474Z" }, + { url = "https://files.pythonhosted.org/packages/df/6d/c5fad00d82b3c7a3ab6189bd4b10e60466f22cfe8a08a9394185c8a8111c/tomli-2.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01f520d4f53ef97964a240a035ec2a869fe1a37dde002b57ebc4417a27ccd853", size = 252084, upload-time = "2026-03-25T20:21:45.62Z" }, + { url = "https://files.pythonhosted.org/packages/00/71/3a69e86f3eafe8c7a59d008d245888051005bd657760e96d5fbfb0b740c2/tomli-2.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7f94b27a62cfad8496c8d2513e1a222dd446f095fca8987fceef261225538a15", size = 247973, upload-time = "2026-03-25T20:21:46.937Z" }, + { url = "https://files.pythonhosted.org/packages/67/50/361e986652847fec4bd5e4a0208752fbe64689c603c7ae5ea7cb16b1c0ca/tomli-2.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ede3e6487c5ef5d28634ba3f31f989030ad6af71edfb0055cbbd14189ff240ba", size = 256223, upload-time = "2026-03-25T20:21:48.467Z" }, + { url = "https://files.pythonhosted.org/packages/8c/9a/b4173689a9203472e5467217e0154b00e260621caa227b6fa01feab16998/tomli-2.4.1-cp314-cp314-win32.whl", hash = "sha256:3d48a93ee1c9b79c04bb38772ee1b64dcf18ff43085896ea460ca8dec96f35f6", size = 98973, upload-time = "2026-03-25T20:21:49.526Z" }, + { url = "https://files.pythonhosted.org/packages/14/58/640ac93bf230cd27d002462c9af0d837779f8773bc03dee06b5835208214/tomli-2.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:88dceee75c2c63af144e456745e10101eb67361050196b0b6af5d717254dddf7", size = 109082, upload-time = "2026-03-25T20:21:50.506Z" }, + { url = "https://files.pythonhosted.org/packages/d5/2f/702d5e05b227401c1068f0d386d79a589bb12bf64c3d2c72ce0631e3bc49/tomli-2.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:b8c198f8c1805dc42708689ed6864951fd2494f924149d3e4bce7710f8eb5232", size = 96490, upload-time = "2026-03-25T20:21:51.474Z" }, + { url = "https://files.pythonhosted.org/packages/45/4b/b877b05c8ba62927d9865dd980e34a755de541eb65fffba52b4cc495d4d2/tomli-2.4.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:d4d8fe59808a54658fcc0160ecfb1b30f9089906c50b23bcb4c69eddc19ec2b4", size = 164263, upload-time = "2026-03-25T20:21:52.543Z" }, + { url = "https://files.pythonhosted.org/packages/24/79/6ab420d37a270b89f7195dec5448f79400d9e9c1826df982f3f8e97b24fd/tomli-2.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7008df2e7655c495dd12d2a4ad038ff878d4ca4b81fccaf82b714e07eae4402c", size = 160736, upload-time = "2026-03-25T20:21:53.674Z" }, + { url = "https://files.pythonhosted.org/packages/02/e0/3630057d8eb170310785723ed5adcdfb7d50cb7e6455f85ba8a3deed642b/tomli-2.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d8591993e228b0c930c4bb0db464bdad97b3289fb981255d6c9a41aedc84b2d", size = 270717, upload-time = "2026-03-25T20:21:55.129Z" }, + { url = "https://files.pythonhosted.org/packages/7a/b4/1613716072e544d1a7891f548d8f9ec6ce2faf42ca65acae01d76ea06bb0/tomli-2.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:734e20b57ba95624ecf1841e72b53f6e186355e216e5412de414e3c51e5e3c41", size = 278461, upload-time = "2026-03-25T20:21:56.228Z" }, + { url = "https://files.pythonhosted.org/packages/05/38/30f541baf6a3f6df77b3df16b01ba319221389e2da59427e221ef417ac0c/tomli-2.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8a650c2dbafa08d42e51ba0b62740dae4ecb9338eefa093aa5c78ceb546fcd5c", size = 274855, upload-time = "2026-03-25T20:21:57.653Z" }, + { url = "https://files.pythonhosted.org/packages/77/a3/ec9dd4fd2c38e98de34223b995a3b34813e6bdadf86c75314c928350ed14/tomli-2.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:504aa796fe0569bb43171066009ead363de03675276d2d121ac1a4572397870f", size = 283144, upload-time = "2026-03-25T20:21:59.089Z" }, + { url = "https://files.pythonhosted.org/packages/ef/be/605a6261cac79fba2ec0c9827e986e00323a1945700969b8ee0b30d85453/tomli-2.4.1-cp314-cp314t-win32.whl", hash = "sha256:b1d22e6e9387bf4739fbe23bfa80e93f6b0373a7f1b96c6227c32bef95a4d7a8", size = 108683, upload-time = "2026-03-25T20:22:00.214Z" }, + { url = "https://files.pythonhosted.org/packages/12/64/da524626d3b9cc40c168a13da8335fe1c51be12c0a63685cc6db7308daae/tomli-2.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2c1c351919aca02858f740c6d33adea0c5deea37f9ecca1cc1ef9e884a619d26", size = 121196, upload-time = "2026-03-25T20:22:01.169Z" }, + { url = "https://files.pythonhosted.org/packages/5a/cd/e80b62269fc78fc36c9af5a6b89c835baa8af28ff5ad28c7028d60860320/tomli-2.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:eab21f45c7f66c13f2a9e0e1535309cee140182a9cdae1e041d02e47291e8396", size = 100393, upload-time = "2026-03-25T20:22:02.137Z" }, + { url = "https://files.pythonhosted.org/packages/7b/61/cceae43728b7de99d9b847560c262873a1f6c98202171fd5ed62640b494b/tomli-2.4.1-py3-none-any.whl", hash = "sha256:0d85819802132122da43cb86656f8d1f8c6587d54ae7dcaf30e90533028b49fe", size = 14583, upload-time = "2026-03-25T20:22:03.012Z" }, +] + +[[package]] +name = "tomlkit" +version = "0.14.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/c3/af/14b24e41977adb296d6bd1fb59402cf7d60ce364f90c890bd2ec65c43b5a/tomlkit-0.14.0.tar.gz", hash = "sha256:cf00efca415dbd57575befb1f6634c4f42d2d87dbba376128adb42c121b87064", size = 187167, upload-time = "2026-01-13T01:14:53.304Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/b5/11/87d6d29fb5d237229d67973a6c9e06e048f01cf4994dee194ab0ea841814/tomlkit-0.14.0-py3-none-any.whl", hash = "sha256:592064ed85b40fa213469f81ac584f67a4f2992509a7c3ea2d632208623a3680", size = 39310, upload-time = "2026-01-13T01:14:51.965Z" }, +] + +[[package]] +name = "tornado" +version = "6.5.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/f8/f1/3173dfa4a18db4a9b03e5d55325559dab51ee653763bb8745a75af491286/tornado-6.5.5.tar.gz", hash = "sha256:192b8f3ea91bd7f1f50c06955416ed76c6b72f96779b962f07f911b91e8d30e9", size = 516006, upload-time = "2026-03-10T21:31:02.067Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/59/8c/77f5097695f4dd8255ecbd08b2a1ed8ba8b953d337804dd7080f199e12bf/tornado-6.5.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:487dc9cc380e29f58c7ab88f9e27cdeef04b2140862e5076a66fb6bb68bb1bfa", size = 445983, upload-time = "2026-03-10T21:30:44.28Z" }, + { url = "https://files.pythonhosted.org/packages/ab/5e/7625b76cd10f98f1516c36ce0346de62061156352353ef2da44e5c21523c/tornado-6.5.5-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:65a7f1d46d4bb41df1ac99f5fcb685fb25c7e61613742d5108b010975a9a6521", size = 444246, upload-time = "2026-03-10T21:30:46.571Z" }, + { url = "https://files.pythonhosted.org/packages/b2/04/7b5705d5b3c0fab088f434f9c83edac1573830ca49ccf29fb83bf7178eec/tornado-6.5.5-cp39-abi3-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:e74c92e8e65086b338fd56333fb9a68b9f6f2fe7ad532645a290a464bcf46be5", size = 447229, upload-time = "2026-03-10T21:30:48.273Z" }, + { url = "https://files.pythonhosted.org/packages/34/01/74e034a30ef59afb4097ef8659515e96a39d910b712a89af76f5e4e1f93c/tornado-6.5.5-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:435319e9e340276428bbdb4e7fa732c2d399386d1de5686cb331ec8eee754f07", size = 448192, upload-time = "2026-03-10T21:30:51.22Z" }, + { url = "https://files.pythonhosted.org/packages/be/00/fe9e02c5a96429fce1a1d15a517f5d8444f9c412e0bb9eadfbe3b0fc55bf/tornado-6.5.5-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:3f54aa540bdbfee7b9eb268ead60e7d199de5021facd276819c193c0fb28ea4e", size = 448039, upload-time = "2026-03-10T21:30:53.52Z" }, + { url = "https://files.pythonhosted.org/packages/82/9e/656ee4cec0398b1d18d0f1eb6372c41c6b889722641d84948351ae19556d/tornado-6.5.5-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36abed1754faeb80fbd6e64db2758091e1320f6bba74a4cf8c09cd18ccce8aca", size = 447445, upload-time = "2026-03-10T21:30:55.541Z" }, + { url = "https://files.pythonhosted.org/packages/5a/76/4921c00511f88af86a33de770d64141170f1cfd9c00311aea689949e274e/tornado-6.5.5-cp39-abi3-win32.whl", hash = "sha256:dd3eafaaeec1c7f2f8fdcd5f964e8907ad788fe8a5a32c4426fbbdda621223b7", size = 448582, upload-time = "2026-03-10T21:30:57.142Z" }, + { url = "https://files.pythonhosted.org/packages/2c/23/f6c6112a04d28eed765e374435fb1a9198f73e1ec4b4024184f21faeb1ad/tornado-6.5.5-cp39-abi3-win_amd64.whl", hash = "sha256:6443a794ba961a9f619b1ae926a2e900ac20c34483eea67be4ed8f1e58d3ef7b", size = 448990, upload-time = "2026-03-10T21:30:58.857Z" }, + { url = "https://files.pythonhosted.org/packages/b7/c8/876602cbc96469911f0939f703453c1157b0c826ecb05bdd32e023397d4e/tornado-6.5.5-cp39-abi3-win_arm64.whl", hash = "sha256:2c9a876e094109333f888539ddb2de4361743e5d21eece20688e3e351e4990a6", size = 448016, upload-time = "2026-03-10T21:31:00.43Z" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/eb/79/72064e6a701c2183016abbbfedaba506d81e30e232a68c9f0d6f6fcd1574/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7", size = 161621, upload-time = "2024-04-19T11:11:49.746Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/00/c0/8f5d070730d7836adc9c9b6408dec68c6ced86b304a9b26a14df072a6e8c/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f", size = 85359, upload-time = "2024-04-19T11:11:46.763Z" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" }, +] + +[[package]] +name = "wcwidth" +version = "0.7.0" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/2c/ee/afaf0f85a9a18fe47a67f1e4422ed6cf1fe642f0ae0a2f81166231303c52/wcwidth-0.7.0.tar.gz", hash = "sha256:90e3a7ea092341c44b99562e75d09e4d5160fe7a3974c6fb842a101a95e7eed0", size = 182132, upload-time = "2026-05-02T16:04:12.653Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/41/52/e465037f5375f43533d1a80b6923955201596a99142ed524d77b571a1418/wcwidth-0.7.0-py3-none-any.whl", hash = "sha256:5d69154c429a82910e241c738cd0e2976fac8a2dd47a1a805f4afed1c0f136f2", size = 110825, upload-time = "2026-05-02T16:04:11.033Z" }, +] diff --git a/til-26-ae-repo/train.py b/til-26-ae-repo/train.py new file mode 100644 index 0000000000000000000000000000000000000000..d18bf818b7e1e5870cdda0c5a07d47ed19a9ed8b --- /dev/null +++ b/til-26-ae-repo/train.py @@ -0,0 +1,358 @@ +#!/usr/bin/env python3 +""" +TIL-26-AE Bomberman Agent Training +Runs inside the Space using local til_environment at ./til-26-ae/til_environment/ +Saves checkpoints to /data/ (Space persistent storage) + pushes to Hub. +""" + +import os +import sys +import numpy as np +import gymnasium as gym +from gymnasium.spaces import Box, Discrete +import torch + +# In the Space, til-26-ae is at the repo root +TIL_PATH = os.path.join(os.path.dirname(__file__), "til-26-ae") +if os.path.isdir(TIL_PATH): + sys.path.insert(0, TIL_PATH) + print(f"Using til_environment from: {TIL_PATH}") +else: + print(f"ERROR: {TIL_PATH} not found") + sys.exit(1) + +from til_environment.bomberman_env import Bomberman +from til_environment.config import default_config +from pettingzoo.utils.conversions import aec_to_parallel +from sb3_contrib import MaskablePPO +from sb3_contrib.common.wrappers import ActionMasker +from stable_baselines3.common.callbacks import BaseCallback, CheckpointCallback +from stable_baselines3.common.monitor import Monitor +from huggingface_hub import HfApi + +# --------------------------------------------------------------------------- +# Environment wrappers +# --------------------------------------------------------------------------- + +class BombermanSingleAgentEnv(gym.Env): + def __init__(self, cfg=None, seed=None): + super().__init__() + self.cfg = cfg or default_config() + self.cfg.env.render_mode = None + raw = Bomberman(self.cfg) + self._parallel_env = aec_to_parallel(raw) + self.agent_id = "agent_0" + self._episode_count = 0 + self.action_space = Discrete(6) + self._last_action_mask = None + self._obs_size = None + self._last_obs_dict = None + self._compute_obs_space() + + def _compute_obs_space(self): + cfg = self.cfg + vl = int(cfg.dynamics.vision.behind) + int(cfg.dynamics.vision.ahead) + 1 + vw = int(cfg.dynamics.vision.left) + int(cfg.dynamics.vision.right) + 1 + av = vl * vw * 25 + br = int(cfg.entities.base.vision_radius) + bs = 2 * br + 1 + bv = bs * bs * 25 + self._obs_size = av + bv + 11 + self.observation_space = Box(low=-np.inf, high=np.inf, shape=(self._obs_size,), dtype=np.float32) + + def reset(self, seed=None, options=None): + self._episode_count += 1 + obs_dict, info_dict = self._parallel_env.reset(seed=self._episode_count, options=options) + self._last_obs_dict = obs_dict + self._last_action_mask = obs_dict[self.agent_id]["action_mask"].astype(bool) + return self._flatten(obs_dict[self.agent_id]), {} + + def step(self, action): + actions = {self.agent_id: action} + for aid, obs in self._last_obs_dict.items(): + if aid != self.agent_id: + valid = np.where(obs["action_mask"] == 1)[0] + actions[aid] = int(np.random.choice(valid)) if len(valid) > 0 else 0 + obs_dict, rewards, terminations, truncations, infos = self._parallel_env.step(actions) + self._last_obs_dict = obs_dict + if self.agent_id not in obs_dict: + return np.zeros(self._obs_size, dtype=np.float32), 0.0, True, False, {} + self._last_action_mask = obs_dict[self.agent_id]["action_mask"].astype(bool) + obs = self._flatten(obs_dict[self.agent_id]) + r = float(rewards.get(self.agent_id, 0.0)) + done = terminations.get(self.agent_id, False) or truncations.get(self.agent_id, False) + return obs, r, done, False, infos.get(self.agent_id, {}) + + def action_masks(self): + return self._last_action_mask + + def _flatten(self, od): + return np.concatenate([ + od["agent_viewcone"].flatten(), od["base_viewcone"].flatten(), + np.array([od["direction"]], dtype=np.float32), + od["location"].flatten().astype(np.float32), + od["base_location"].flatten().astype(np.float32), + od["health"].flatten().astype(np.float32), + np.array([od["frozen_ticks"]], dtype=np.float32), + od["base_health"].flatten().astype(np.float32), + od["team_resources"].flatten().astype(np.float32), + np.array([od["team_bombs"]], dtype=np.float32), + np.array([od["step"]], dtype=np.float32), + ], dtype=np.float32) + + def close(self): + self._parallel_env.close() + + +class RewardShapingWrapper(gym.Wrapper): + def __init__(self, env, adaptive_k=1.2, base_explore_weight=0.5): + super().__init__(env) + self.adaptive_k = adaptive_k + self.base_explore_weight = base_explore_weight + self._visit_counts = None + self._grid_size = 16 + self._avg_enemy_deaths = 0.0 + self._explore_weight = base_explore_weight + + def reset(self, **kwargs): + self._visit_counts = np.zeros((self._grid_size, self._grid_size), dtype=np.int32) + return self.env.reset(**kwargs) + + def step(self, action): + obs, reward, done, truncated, info = self.env.step(action) + pos = info.get("location", None) + bonus = 0.0 + if pos is not None: + x, y = int(pos[0]), int(pos[1]) + if 0 <= x < self._grid_size and 0 <= y < self._grid_size: + bonus = 1.0 / (1.0 + self._visit_counts[x, y]) + self._visit_counts[x, y] += 1 + if done: + alpha = 1.0 - np.tanh(self.adaptive_k * self._avg_enemy_deaths) + self._explore_weight = self.base_explore_weight * max(0.1, alpha) + return obs, reward + self._explore_weight * bonus, done, truncated, info + + def action_masks(self): + return self.env.action_masks() + + +class RuleBasedOpponent: + def __init__(self, difficulty="simple"): + self.difficulty = difficulty + + def act(self, od): + valid = np.where(od["action_mask"] == 1)[0] + if len(valid) == 0: + return 4 + if self.difficulty == "static": + return 4 + if self.difficulty == "simple": + vc = od["agent_viewcone"] + if (np.any(vc[..., 10] > 0) or np.any(vc[..., 12] > 0)) and 5 in valid: + return 5 + mv = [a for a in valid if a < 4] + return int(np.random.choice(mv)) if mv else 4 + return 4 + + +class CurriculumEnv(gym.Env): + STAGES = ["static", "simple", "smart", "mixed"] + WIN_RATE = 0.55 + EPS_PER_STAGE = 500 + + def __init__(self, cfg=None, seed=None): + super().__init__() + self.cfg = cfg or default_config() + self.cfg.env.render_mode = None + self._parallel_env = aec_to_parallel(Bomberman(self.cfg)) + self.agent_id = "agent_0" + self._episode_count = 0 + self.action_space = Discrete(6) + self._last_action_mask = None + self._obs_size = None + self._last_obs_dict = None + self._compute_obs_space() + self.stage_idx = 0 + self.stage_eps = 0 + self.stage_wins = 0 + self.stage_rewards = [] + self.opponents = {} + self._init_opponents() + + def _compute_obs_space(self): + cfg = self.cfg + vl = int(cfg.dynamics.vision.behind) + int(cfg.dynamics.vision.ahead) + 1 + vw = int(cfg.dynamics.vision.left) + int(cfg.dynamics.vision.right) + 1 + av = vl * vw * 25 + br = int(cfg.entities.base.vision_radius) + bs = 2 * br + 1 + bv = bs * bs * 25 + self._obs_size = av + bv + 11 + self.observation_space = Box(low=-np.inf, high=np.inf, shape=(self._obs_size,), dtype=np.float32) + + def _init_opponents(self): + for i in range(1, self.cfg.env.num_teams): + self.opponents[f"agent_{i}"] = RuleBasedOpponent(difficulty="static") + + def _update_difficulty(self): + stage = self.STAGES[self.stage_idx] + for oid, opp in self.opponents.items(): + opp.difficulty = "smart" if (stage == "mixed" and int(oid.split("_")[1]) % 2 == 0) else stage + + def _check_advance(self): + if self.stage_idx >= len(self.STAGES) - 1: + return False + if len(self.stage_rewards) >= self.EPS_PER_STAGE: + wr = self.stage_wins / max(1, len(self.stage_rewards)) + if wr >= self.WIN_RATE: + print(f"Stage {self.STAGES[self.stage_idx]} done (wr={wr:.1%}). Advancing.") + self.stage_idx += 1 + self.stage_eps = self.stage_wins = 0 + self.stage_rewards = [] + self._update_difficulty() + return True + return False + + def reset(self, seed=None, options=None): + self._episode_count += 1 + obs_dict, info_dict = self._parallel_env.reset(seed=self._episode_count, options=options) + self._last_obs_dict = obs_dict + self._last_action_mask = obs_dict[self.agent_id]["action_mask"].astype(bool) + return self._flatten(obs_dict[self.agent_id]), {} + + def step(self, action): + actions = {self.agent_id: action} + for aid, obs in self._last_obs_dict.items(): + if aid != self.agent_id: + opp = self.opponents.get(aid) + actions[aid] = opp.act(obs) if opp else 4 + obs_dict, rewards, terminations, truncations, infos = self._parallel_env.step(actions) + self._last_obs_dict = obs_dict + if self.agent_id not in obs_dict: + self.stage_eps += 1 + return np.zeros(self._obs_size, dtype=np.float32), 0.0, True, False, {} + self._last_action_mask = obs_dict[self.agent_id]["action_mask"].astype(bool) + obs = self._flatten(obs_dict[self.agent_id]) + r = float(rewards.get(self.agent_id, 0.0)) + done = terminations.get(self.agent_id, False) or truncations.get(self.agent_id, False) + if done: + self.stage_eps += 1 + self.stage_rewards.append(r) + if r > 10.0: + self.stage_wins += 1 + self._check_advance() + return obs, r, done, False, {"stage": self.stage_idx, "stage_name": self.STAGES[self.stage_idx]} + + def action_masks(self): + return self._last_action_mask + + def _flatten(self, od): + return np.concatenate([ + od["agent_viewcone"].flatten(), od["base_viewcone"].flatten(), + np.array([od["direction"]], dtype=np.float32), + od["location"].flatten().astype(np.float32), + od["base_location"].flatten().astype(np.float32), + od["health"].flatten().astype(np.float32), + np.array([od["frozen_ticks"]], dtype=np.float32), + od["base_health"].flatten().astype(np.float32), + od["team_resources"].flatten().astype(np.float32), + np.array([od["team_bombs"]], dtype=np.float32), + np.array([od["step"]], dtype=np.float32), + ], dtype=np.float32) + + def close(self): + self._parallel_env.close() + + +# --------------------------------------------------------------------------- +# Persistent storage helpers +# --------------------------------------------------------------------------- + +DATA_DIR = "/data" +os.makedirs(DATA_DIR, exist_ok=True) +HUB_REPO = os.environ.get("HUB_MODEL_ID", "E-Rong/til-26-ae-agent") + +def hub_push(local_path, repo_path): + try: + HfApi().upload_file(path_or_fileobj=local_path, path_in_repo=repo_path, + repo_id=HUB_REPO, repo_type="model") + print(f" -> pushed {repo_path} to {HUB_REPO}") + except Exception as e: + print(f" -> push failed: {e}") + + +class DualSaveCallback(BaseCallback): + """Saves to local /data/ AND pushes to Hub.""" + def __init__(self, save_freq=50000, verbose=0): + super().__init__(verbose) + self.save_freq = save_freq + + def _on_step(self) -> bool: + if self.num_timesteps % self.save_freq == 0: + local = os.path.join(DATA_DIR, f"ckpt_{self.num_timesteps}.zip") + self.model.save(local) + hub_push(local, f"ckpt_{self.num_timesteps}.zip") + print(f"Checkpoint at {self.num_timesteps} saved to {local}") + return True + + +# --------------------------------------------------------------------------- +# Training phases +# --------------------------------------------------------------------------- + +def train_phase(phase, total_timesteps, model=None): + cfg = default_config() + cfg.env.render_mode = None + + if phase == 1: + print("=== Phase 1: MaskablePPO vs Random ===") + env = ActionMasker(Monitor(BombermanSingleAgentEnv(cfg=cfg)), lambda e: e.action_masks()) + elif phase == 2: + print("=== Phase 2: + Exploration Shaping ===") + base = BombermanSingleAgentEnv(cfg=cfg) + env = ActionMasker(Monitor(RewardShapingWrapper(base)), lambda e: e.action_masks()) + elif phase == 3: + print("=== Phase 3: Curriculum Self-Play ===") + cfg.env.num_teams = 3 + env = ActionMasker(Monitor(CurriculumEnv(cfg=cfg)), lambda e: e.action_masks()) + else: + raise ValueError(phase) + + if model is None: + print("Creating MaskablePPO...") + model = MaskablePPO( + "MlpPolicy", env, + learning_rate=3e-4, n_steps=2048, batch_size=64, n_epochs=10, + gamma=0.99, gae_lambda=0.95, clip_range=0.2, + ent_coef=0.01, vf_coef=0.5, max_grad_norm=0.5, + verbose=1, + device="cuda" if torch.cuda.is_available() else "cpu", + ) + else: + model.set_env(env) + + cb = [CheckpointCallback(save_freq=50000, save_path=DATA_DIR, name_prefix=f"phase{phase}"), + DualSaveCallback(save_freq=50000)] + model.learn(total_timesteps=total_timesteps, callback=cb, progress_bar=False) + final = os.path.join(DATA_DIR, f"phase{phase}_final.zip") + model.save(final) + hub_push(final, f"phase{phase}_final.zip") + env.close() + print(f"Phase {phase} complete.") + return model + + +def main(): + ts = os.environ.get("TOTAL_TIMESTEPS", "500000:500000:1000000") + phase_ts = [int(x.replace("_", "")) for x in ts.split(":")] + print(f"Phase timesteps: {phase_ts}") + + model = None + for i, t in enumerate(phase_ts[:3], 1): + model = train_phase(i, t, model) + + print("\n=== All phases complete ===") + + +if __name__ == "__main__": + main()