diff --git a/.gitignore b/.gitignore index da42ee34..f5755c7e 100644 --- a/.gitignore +++ b/.gitignore @@ -10,8 +10,10 @@ .idea .vscode .envrc +tmp/ # virtualenv/venv directories +**/.venv/ /venv/ /bin/ /include/ diff --git a/.python-version b/.python-version new file mode 100644 index 00000000..f3fe474a --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.12.9 diff --git a/docs/models.md b/docs/models.md index cd758a90..2ddee510 100644 --- a/docs/models.md +++ b/docs/models.md @@ -62,7 +62,7 @@ Adding the new model needs to following the naming convention that Tunix support ## AutoModel `AutoModel` provides a unified interface for instantiating Tunix models from -pretrained checkpoints, similar to the Hugging Face `AutoModel` API. It allows +pretrained checkpoints, similar to the Huggingface `AutoModel` API. It allows you to load a model simply by providing its `model_id`, handling the download and initialization for you. @@ -70,7 +70,7 @@ and initialization for you. To load a model, use the `AutoModel.from_pretrained` method with the model identifier and your JAX sharding mesh. By default this will download the model -from HuggingFace. +from Huggingface. ```python from tunix.models.automodel import AutoModel @@ -80,9 +80,9 @@ import jax mesh = jax.make_mesh((1, 1), ("fsdp", "tp"), axis_types=(jax.sharding.AxisType.Auto,) * 2) # 2. Load the model -# By default, this downloads from Hugging Face. +# By default, this downloads from Huggingface. model, model_path = AutoModel.from_pretrained( - model_id="google/gemma-2-2b-it", + model_id="google/gemma-2-2b-it", # Using HF id as model_id mesh=mesh ) @@ -94,20 +94,19 @@ print(f"Model loaded from: {model_path}") You can load models from different sources (e.g., Kaggle, GCS, etc.) using the `model_source` argument. -#### From HuggingFace: +#### From Huggingface: This is the default choice (`ModelSource.HUGGINGFACE`) as shown in the example above. #### From Kaggle: -For Kaggle, you must provide the `model_id` which is the Hugging Face identifier -(to determine the model configuration) and the `model_path` which is the Kaggle +For Kaggle, you must provide the `model_id` which is the Huggingface identifier or model_config_id (see [Naming Conventions](models.md#naming-conventions)) to determine the model configuration and the `model_path` which is the Kaggle Hub model identifier (used to download the model from Kaggle). ```python model, model_path = AutoModel.from_pretrained( - model_id="google/gemma2-2b-it", + model_id="gemma2_2b_it", # Using model_config_id as model_id mesh=mesh, model_source=ModelSource.KAGGLE, model_path="google/gemma-2/flax/gemma2-2b-it", @@ -120,13 +119,12 @@ For example the `model_path` for the `google/gemma-2/flax/gemma2-2b-it` is extra #### From GCS: -For GCS, you must provide the `model_id` which is the Hugging Face identifier -(to determine the model configuration) and the `model_path` (the actual GCS +For GCS, you must provide the `model_id` which is the Huggingface identifier or model_config_id (see [Naming Conventions](models.md#naming-conventions)) to determine the model configuration and the `model_path` (the actual GCS location). ```python model, model_path = AutoModel.from_pretrained( - model_id="google/gemma-2-2b-it", + model_id="gemma2_2b_it", # Using model_config_id as model_id mesh=mesh, model_source=ModelSource.GCS, model_path="gs://my-bucket/gemma-2-2b-it" @@ -139,7 +137,7 @@ Optionally, you can also provide the `model_download_path` argument, which specifies where the model is to be downloaded to. Depending on the `model_source` the effect of specifying this variable is different: -* **Hugging Face**: Files are downloaded directly to this directory. +* **Huggingface**: Files are downloaded directly to this directory. * **Kaggle**: Sets the `KAGGLEHUB_CACHE` environment variable to this path. * **GCS**: No-op. * **Internal**: Files are copied to this directory. If omitted, the model is loaded directly from the `model_path`. This mode (Internal) is not supported in OSS version. @@ -148,21 +146,27 @@ specifies where the model is to be downloaded to. Depending on the This section outlines the naming conventions used within Tunix for model identification and configuration. These conventions ensure consistency when -loading models from various sources like Hugging Face or Kaggle. +loading models from various sources like Huggingface or Kaggle. The `ModelNaming` dataclass handles the parsing and standardization of model names. -* **`model_id`**: The full model name identifier (case sensitive), as it appears - on Hugging Face, including the parent directory. For example, +* **`model_id`**: This is a unique identifier used to identifty the model in mind and extract the family, version, and desired config from. Tunix support two identifiers as the `model_id`: + 1. **Huggingface (HF) IDs:** The full model name identifier (case sensitive), as it appears + on Huggingface, including the parent directory. + * **Extracting model_id from HF**: For example, `meta-llama/Llama-3.1-8B` is extracted as shown below: - ![Hugging Face extracting Model ID](images/model_id_huggingface.png){: width="75%"} + ![Huggingface extracting Model ID](images/model_id_huggingface.png){: width="75%"} + + 2. **Native Tunix model_configs:** the `model_config_id` representing the exact config from the model class can be used directly as the `model_id`. In this case it will also be treated as the `model_name`. + * **Extracting model_id from model_config_id**: In this case, you would need to refer to the source code (`model.py`) for each model family and select the config id from the `ModelConfig` class, for example `llama3p1_8b` from the llama [model code](https://github.com/google/tunix/blob/main/models/llama3/model.py;bpv=1;bpt=1;l=138). * **`model_name`**: The unique full name identifier of the model. This corresponds to the full name and should match exactly with the model name used in Hugging Face or Kaggle. It is typically all lowercase and formatted - as `-`. - * *Example*: `gemma-2b`, `llama-3.1-8b`, `gemma2-2b-it`. + as `-` (when HF is used for model_id) or `_` (when model_config_id is used for model_id) . + * *Example for HF as model_id*: `gemma-2b`, `llama-3.1-8b`, `gemma-2-2b-it`. + * *Example for model_config_id as model_id*: `gemma_2b`, `llama3p1_8b`, `gemma2_2b_it`. * **`model_family`**: The standardized model family. Unnecessary hyphens are removed, and versions are standardized (e.g., replacing dot with `p`). diff --git a/docs/quickstart.md b/docs/quickstart.md index 21aff51d..de2a5c9e 100644 --- a/docs/quickstart.md +++ b/docs/quickstart.md @@ -184,7 +184,7 @@ Next, we load the English-French translation dataset. Note you can use your own datasets too (PyGrain, Hugging Face dataset, TFDS, etc.). ```sh -gsutil cp gs://gemma-data/tokenizers/tokenizer_gemma3.model . +gcloud storage cp gs://gemma-data/tokenizers/tokenizer_gemma3.model . ``` ```python diff --git a/examples/README.rst b/examples/README.rst index 6a400ff8..9f83f453 100644 --- a/examples/README.rst +++ b/examples/README.rst @@ -68,9 +68,20 @@ Create a v5litepod-8 TPU VM in GCE: Reference: `TPU Runtime Versions `_ +``` +gcloud compute tpus tpu-vm create v5-8 \ + --zone=us-west1-c \ + --accelerator-type=v5litepod-8 \ + --version=v2-alpha-tpuv5-lite +``` + 2. Configure VM ~~~~~~~~~~~~~~~~ +``` +gcloud compute tpus tpu-vm ssh --zone "us-west1-c" "v5-8" +``` + SSH into the VM using the supplied gcloud command, then run: .. code-block:: bash diff --git a/examples/deepscaler/train_deepscaler_nb.py b/examples/deepscaler/train_deepscaler_nb.py index 271b6b2a..557a7af2 100644 --- a/examples/deepscaler/train_deepscaler_nb.py +++ b/examples/deepscaler/train_deepscaler_nb.py @@ -9,12 +9,38 @@ import grain import jax from jax import numpy as jnp -import numpy as np import optax import optax from orbax import checkpoint as ocp import qwix -from tqdm.auto import tqdm + +import math +import logging +import sys +from absl import logging as absl_logging + +# ====== Logging Configuration ====== +# 1. Force absl to use python logging +absl_logging.use_python_logging() + +# 2. Configure the root logger +logging.basicConfig( + stream=sys.stdout, + level=logging.INFO, + format="%(asctime)s - %(levelname)s - [%(name)s] %(message)s", + datefmt="%Y-%m-%d %H:%M:%S", + force=True +) + +# 3. Explicitly set levels for relevant loggers +logging.getLogger().setLevel(logging.INFO) +logging.getLogger('absl').setLevel(logging.INFO) + +# 4. Set absl verbosity +absl_logging.set_verbosity(absl_logging.INFO) +absl_logging.set_stderrthreshold('info') + +print("Logging configured at INFO level.") try: from etils import ecolab @@ -42,6 +68,15 @@ from tunix.sft import utils as sft_utils from tunix.utils import math_rewards from tunix.utils import compat + from tunix.cli.utils import data as data_lib + +try: + import pathwaysutils + pathwaysutils.initialize() +except: + pass + +print("jax devices: ", jax.devices()) # %% # ====== Data ====== @@ -57,6 +92,8 @@ # ====== Sharding ====== MESH = [(2, 4), ("fsdp", "tp")] +ROLLOUT_MESH = [(1, 4), ("fsdp", "tp")] +TRAINER_MESH = [(2, 2), ("fsdp", "tp")] # ====== GRPO ====== # === Generation during GRPO training === @@ -84,6 +121,7 @@ EPSILON = 0.2 # ====== Training ====== +ENABLE_REMAT = True BATCH_SIZE = 128 MINI_BATCH_SIZE = 64 NUM_BATCHES = 100 @@ -127,17 +165,53 @@ "liberal": {"temperature": 0.85, "top_k": 2000, "top_p": 1.0}, } # ====== Rollout ====== -ROLLOUT_ENGINE = "sglang_jax" # one of "vanilla", "vllm" or "sglang_jax" +ROLLOUT_ENGINE = os.getenv( + "ROLLOUT_ENGINE", "sglang_jax" +) # one of "vanilla", "vllm" or "sglang_jax" + +# mesh = jax.make_mesh( +# *MESH, axis_types=(jax.sharding.AxisType.Auto,) * len(MESH[0]) +# ) +mesh = None + +trainer_devices = math.prod(TRAINER_MESH[0]) +rollout_devices = math.prod(ROLLOUT_MESH[0]) + +if trainer_devices + rollout_devices > jax.device_count(): + raise ValueError( + "Trainer devices must be less than or equal to the number of devices" + " available." + ) + + +if ROLLOUT_ENGINE in ("sglang_jax", "vllm"): + rollout_device_list = jax._src.mesh_utils.create_device_mesh( + ROLLOUT_MESH[0], jax.devices()[:rollout_devices] + ) -mesh = jax.make_mesh( - *MESH, axis_types=(jax.sharding.AxisType.Auto,) * len(MESH[0]) -) -if ROLLOUT_ENGINE == "sglang_jax": rollout_mesh = jax.sharding.Mesh( - np.array(jax.devices())[:4].reshape(1, 4), ("fsdp", "tp") + rollout_device_list, + axis_names = ROLLOUT_MESH[1], + axis_types = (jax.sharding.AxisType.Auto,) * len(ROLLOUT_MESH[0]), + ) + # rollout_mesh = jax.make_mesh( + # *ROLLOUT_MESH, + # devices=jax.devices()[:rollout_devices], + # axis_types=(jax.sharding.AxisType.Auto,) * len(ROLLOUT_MESH[0]), + # ) + print(f"YY {rollout_device_list=} {rollout_mesh.devices=}") + trainer_devices_list = jax._src.mesh_utils.create_device_mesh( + TRAINER_MESH[0], jax.devices()[-trainer_devices:] ) + # trainer_mesh = jax.make_mesh( + # *TRAINER_MESH, + # devices=jax.devices()[-trainer_devices:], + # axis_types=(jax.sharding.AxisType.Auto,) * len(TRAINER_MESH[0]), + # ) trainer_mesh = jax.sharding.Mesh( - np.array(jax.devices())[4:].reshape(2, 2), ("fsdp", "tp") + trainer_devices_list, + axis_names = TRAINER_MESH[1], + axis_types = (jax.sharding.AxisType.Auto,) * len(TRAINER_MESH[0]), ) else: rollout_mesh = mesh @@ -237,22 +311,32 @@ def process_item(item): # %% train_dataset, test_dataset = create_datasets() +train_dataset, val_dataset = data_lib.post_init_dataset( + train_dataset, + tokenizer, + batch_size=BATCH_SIZE, + num_batches=NUM_BATCHES, + max_prompt_length=MAX_PROMPT_LENGTH, + fraction=TRAIN_FRACTION, + num_epochs=NUM_EPOCHS, +) -train_dataset = train_dataset.batch(BATCH_SIZE)[:NUM_BATCHES] -if TRAIN_FRACTION == 1.0: - train_dataset = train_dataset.repeat(NUM_EPOCHS) - val_dataset = None -else: - train_dataset = train_dataset[: int(len(train_dataset) * TRAIN_FRACTION)] - train_dataset = train_dataset.repeat(NUM_EPOCHS) - val_dataset = train_dataset[int(len(train_dataset) * TRAIN_FRACTION) :].repeat(NUM_EPOCHS) -test_dataset = test_dataset.batch(BATCH_SIZE)[:NUM_TEST_BATCHES] +test_dataset, _ = data_lib.post_init_dataset( + test_dataset, + tokenizer, + batch_size=BATCH_SIZE, + num_batches=NUM_TEST_BATCHES, + max_prompt_length=MAX_PROMPT_LENGTH, +) # %% show_hbm_usage("Done with loading datasets") # %% config = model_lib.ModelConfig.deepseek_r1_distill_qwen_1p5b() +if ENABLE_REMAT: + config.remat_config = model_lib.RematConfig.BLOCK + print("MODEL_PATH: ", MODEL_PATH) qwen2_ref = params_lib.create_model_from_safe_tensors( MODEL_PATH, config, trainer_mesh, dtype=jnp.bfloat16 @@ -342,6 +426,56 @@ def get_lora_model(base_model, model_mesh): # Training config print("Rollout mesh: ", rollout_mesh) print("Trainer mesh: ", trainer_mesh) + +base_rollout_dict = { + "max_tokens_to_generate": TOTAL_GENERATION_STEPS, + "max_prompt_length": MAX_PROMPT_LENGTH, + "kv_cache_size": MAX_PROMPT_LENGTH + TOTAL_GENERATION_STEPS + 256, + "temperature": TEMPERATURE, + "top_p": TOP_P, + "top_k": TOP_K, + "eos_tokens": [tokenizer.encode("<|im_end|>")[0]], +} + +sglang_jax_rollout_dict = { + # sglang-jax specific configs + "rollout_sglang_jax_model_version": ( + "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B" + ), + "rollout_sglang_jax_mem_fraction_static": 0.8, + "rollout_sglang_jax_init_with_random_weights": True, + "rollout_sglang_jax_disable_radix_cache": True, + "rollout_sglang_jax_enable_deterministic_sampling": False, + "rollout_sglang_jax_chunked_prefill_size": 2048, + "rollout_sglang_jax_max_running_requests": 32, + "rollout_sglang_jax_page_size": 128, +} + +vllm_rollout_dict = { + # vllm-tpu specific configs + "rollout_vllm_model_version": "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", + "rollout_vllm_hbm_utilization": 0.85, + "rollout_vllm_tpu_backend_type": "jax", + "rollout_vllm_server_mode": True, + "rollout_vllm_async_scheduling": True, + "tensor_parallel_size": ROLLOUT_MESH[0][1], + "data_parallel_size": ROLLOUT_MESH[0][0], + "rollout_vllm_kwargs": {"kv_cache_metrics": True}, +} + +if ROLLOUT_ENGINE == "sglang_jax": + rollout_engine_config = base_rollout.RolloutConfig( + **base_rollout_dict, **sglang_jax_rollout_dict + ) +elif ROLLOUT_ENGINE == "vllm": + rollout_engine_config = base_rollout.RolloutConfig( + **base_rollout_dict, **vllm_rollout_dict + ) +elif ROLLOUT_ENGINE == "vanilla": + rollout_engine_config = base_rollout.RolloutConfig(**base_rollout_dict) +else: + raise ValueError(f"Unsupported rollout engine: {ROLLOUT_ENGINE}") + cluster_config = rl_cluster_lib.ClusterConfig( role_to_mesh={ rl_cluster_lib.Role.ACTOR: trainer_mesh, @@ -367,34 +501,7 @@ def get_lora_model(base_model, model_mesh): checkpoint_root_directory=CKPT_DIR, checkpointing_options=checkpointing_options, ), - rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=TOTAL_GENERATION_STEPS, - max_prompt_length=MAX_PROMPT_LENGTH, - kv_cache_size=MAX_PROMPT_LENGTH + TOTAL_GENERATION_STEPS + 256, - temperature=TEMPERATURE, - top_p=TOP_P, - top_k=TOP_K, - eos_tokens=[tokenizer.encode("<|im_end|>")[0]], - # sglang-jax specific configs - rollout_sglang_jax_model_version=( - "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B" - ), - rollout_sglang_jax_mem_fraction_static=0.8, - rollout_sglang_jax_init_with_random_weights=True, - rollout_sglang_jax_disable_radix_cache=True, - rollout_sglang_jax_enable_deterministic_sampling=False, - rollout_sglang_jax_chunked_prefill_size=2048, - rollout_sglang_jax_max_running_requests=32, - rollout_sglang_jax_page_size=128, - # vllm-tpu specific configs - # rollout_vllm_model_version="deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B", - # rollout_vllm_hbm_utilization=0.2, - # rollout_vllm_tpu_backend_type="jax", - # rollout_vllm_server_mode=True, - # rollout_vllm_async_scheduling=True, - # tensor_parallel_size=4, - # data_parallel_size=2, - ), + rollout_config=rollout_engine_config, ) grpo_config = GRPOConfig( @@ -417,23 +524,6 @@ def get_lora_model(base_model, model_mesh): show_hbm_usage("after RLCluster creation") -# %% -import logging -import sys -# Get the logger for the current module -logger = logging.getLogger(__name__) - -# --- Clear any existing handlers from THIS logger to avoid duplicates --- -for handler in logger.handlers[:]: - logger.removeHandler(handler) - -# Configure the root logger -logging.basicConfig( - stream=sys.stdout, # Direct logs to standard output (notebook cell) - level=logging.INFO, # Set the minimum level to INFO - format="%(asctime)s - %(levelname)s - %(message)s", # Optional: customize the format - datefmt="%Y-%m-%d %H:%M:%S", # Optional: customize the date format -) # %% # GRPO Trainer diff --git a/examples/deepswe/agent_sandbox_test.ipynb b/examples/deepswe/agent_sandbox_test.ipynb new file mode 100644 index 00000000..b944d9c4 --- /dev/null +++ b/examples/deepswe/agent_sandbox_test.ipynb @@ -0,0 +1,690 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "26d4c4a6", + "metadata": {}, + "source": [ + "## Prerequisites\n", + "\n", + "glcoud\n", + "kubectl\n", + "uv\n", + "\n", + "### Create a GKE Cluster\n", + "\n", + "These are the steps for a GKE Standard cluster. You can also use an Autopilot cluster, which handles\n", + "scaling and node pools for you.\n", + "\n", + "```bash\n", + "export PROJECT_ID=$(gcloud config get project)\n", + "export CLUSTER_NAME=tunix-demo\n", + "export LOCATION=us-west1\n", + "export NODE_POOL_NAME=\"gvisor-node-pool\"\n", + "export MACHINE_TYPE=\"n2-standard-16\" # 16 vCPUs, 64GB RAM\n", + "export NUM_NODES=5 # Starting nodes\n", + "```\n", + "\n", + "Create a Standard GKE Cluster. This may take a few minutes:\n", + "\n", + "```bash\n", + "gcloud container clusters create ${CLUSTER_NAME} \\\n", + " --location=${LOCATION}\n", + "```\n", + "\n", + "Creating the cluster will automatically retreive the cluster credentials for you which will allow\n", + "you to run `kubectl` commands. If you need to get them again, run:\n", + "\n", + "```bash\n", + " gcloud container clusters get-credentials ${CLUSTER_NAME} --location ${LOCATION} --project ${PROJECT_ID}\n", + "```\n", + "\n", + "Create a gVisor node pool. This may take a few minutes:\n", + "\n", + "```bash\n", + "gcloud container node-pools create ${NODE_POOL_NAME} \\\n", + " --cluster=${CLUSTER_NAME} \\\n", + " --location=${LOCATION} \\\n", + " --machine-type=${MACHINE_TYPE} \\\n", + " --image-type=cos_containerd \\\n", + " --sandbox type=gvisor \\\n", + " --num-nodes=${NUM_NODES} \\\n", + " --enable-autoscaling \\\n", + " --min-nodes=1 \\\n", + " --max-nodes=100 \\\n", + " --node-labels=\"cloud.google.com/gke-nodepool=${NODE_POOL_NAME}\"\n", + "```\n", + "\n", + "### Install Agent-Sandbox Controller into GKE Cluster\n", + "\n", + "Instructions are copied from https://github.com/kubernetes-sigs/agent-sandbox/releases:\n", + "\n", + "```bash\n", + "kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.1/manifest.yaml\n", + "kubectl apply -f https://github.com/kubernetes-sigs/agent-sandbox/releases/download/v0.1.1/extensions.yaml\n", + "```\n", + "\n", + "### Install Notebook Dependecies\n", + "\n", + "Create virtual environment in the root `~/tunix` directory using commands below.\n", + "In your IDE select that `.venv/bin/python` as the Python Interpreter and Kernel for this notebook.\n", + "\n", + "Note that the `assistant` responses are mocked in this notebook, so this notebook does not\n", + "require a TPU. For actual use follow instructions for creating and connecting to a TPU in\n", + "`~/tunix/examples/README.rst`.\n", + "\n", + "We pin to the same Python version as the Jupyter server in the TPU.\n", + "We use `uv` because this is the method preferred by R2E-Gym.\n", + "\n", + "Run these commands in your terminal at the project root, not in this notebook:\n", + "\n", + "```bash\n", + "sudo apt install python3.12-venv\n", + "uv python pin 3.12.9\n", + "uv sync -U\n", + "```\n", + "\n", + "Activate the virtual environment, and install dependencies specific to this notebook:\n", + "\n", + "```bash\n", + "source ~/tunix/.venv/bin/activate\n", + "uv pip install -U ipykernel ipywidgets kubernetes k8s-agent-sandbox\n", + "```\n", + "\n", + "#### Install Fork of R2E-Gym\n", + "\n", + "Install from a specific git commit\n", + "https://github.com/R2E-Gym/R2E-Gym/commit/36c2497d2b238bf02f1c7d6e5ba2e7ed9911595e with the\n", + "agentic-sandbox changes included.\n", + "\n", + "```bash\n", + "uv pip install \"git+https://github.com/R2E-Gym/R2E-Gym.git@36c2497d2b238bf02f1c7d6e5ba2e7ed9911595e\"\n", + "```\n", + "\n", + "These code changes live on a separate fork of R2E-Gym. This is because R2E-Gym is not being\n", + "actively maintained, so it is unlikely that these changes will be merged into main.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "46265330", + "metadata": {}, + "outputs": [], + "source": [ + "import subprocess\n", + "\n", + "\n", + "def get_uv_pip_list():\n", + " \"\"\"\n", + " Executes 'uv pip list' and captures the output.\n", + " Use ['uv', 'run', 'pip', 'list'] to force environment discovery.\n", + " \"\"\"\n", + " try:\n", + " result = subprocess.run(\n", + " ['uv', 'pip', 'list'],\n", + " capture_output=True,\n", + " text=True,\n", + " check=True\n", + " )\n", + " print(result.stdout)\n", + " except subprocess.CalledProcessError as e:\n", + " print(f\"Error executing uv: {e.stderr}\")\n", + " except FileNotFoundError:\n", + " print(\"The 'uv' executable was not found. Please ensure uv is installed.\")\n", + "\n", + "\n", + "if __name__ == \"__main__\":\n", + " get_uv_pip_list()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "655084d1", + "metadata": {}, + "outputs": [], + "source": [ + "import logging\n", + "import os\n", + "\n", + "# Define the log file\n", + "INFRA_LOG_FILE = \"r2egym_infrastructure.log\"\n", + "\n", + "# Create a single shared logger that ONLY writes to a file\n", + "infra_file_logger = logging.getLogger(\"r2egym_shared_infra\")\n", + "infra_file_logger.handlers = [] # Clear any existing handlers\n", + "infra_file_logger.propagate = False # Stop logs from reaching the notebook console\n", + "\n", + "# Add the file handler\n", + "fh = logging.FileHandler(INFRA_LOG_FILE, mode='w', encoding='utf-8')\n", + "fh.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s'))\n", + "infra_file_logger.addHandler(fh)\n", + "infra_file_logger.setLevel(logging.INFO)\n", + "\n", + "# Also globally silence noisy dependencies\n", + "for noisy_logger in [\"k8s_agent_sandbox\", \"kubernetes\", \"urllib3\", \"absl\"]:\n", + " l = logging.getLogger(noisy_logger)\n", + " l.handlers = []\n", + " l.addHandler(fh) # Send their logs to the same file\n", + " l.propagate = False\n", + " l.setLevel(logging.INFO)\n", + "\n", + "print(f\"Infrastructure logs are now being redirected to: {os.path.abspath(INFRA_LOG_FILE)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03e8c0d8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from datasets import load_dataset\n", + "DATASET_CACHE = os.getenv('DATASET_CACHE', '~/scratch/dataset_cache')\n", + "TASKS_TO_PROCESS = 100" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3b67addc", + "metadata": {}, + "outputs": [], + "source": [ + "from typing import Any, cast\n", + "\n", + "dataset = load_dataset(\n", + " \"R2E-Gym/R2E-Gym-V1\",\n", + " split=\"train\",\n", + " cache_dir=DATASET_CACHE,\n", + " num_proc=32,\n", + ")\n", + "entries = []\n", + "unique_images = set()\n", + "for i, entry in enumerate(dataset):\n", + " # Cast entry to dict to satisfy Pylance\n", + " row = cast(dict[str, Any], entry)\n", + " if \"docker_image\" in row:\n", + " unique_images.add(row[\"docker_image\"])\n", + " entries.append(entry)\n", + " if i >= TASKS_TO_PROCESS - 1:\n", + " break\n", + "unique_images = list(unique_images)\n", + "print(f\"Found {len(unique_images)} unique Docker images to download\")\n", + "IDS = [f\"task-{i}\" for i in range(len(entries))]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e34fb53", + "metadata": {}, + "outputs": [], + "source": [ + "from kubernetes import client, config\n", + "import os\n", + "\n", + "NODE_POOL_NAME = \"gvisor-node-pool\"\n", + "\n", + "os.environ[\"KUBECONFIG\"] = \"~/.kube/config\"\n", + "os.environ[\"NODE_SELECTOR_KEY\"] = \"cloud.google.com/gke-nodepool\"\n", + "# NB: change based on your node pool name\n", + "os.environ[\"NODE_SELECTOR_VAL\"] = NODE_POOL_NAME\n", + "\n", + "config.load_kube_config()\n", + "k8s_client = client.CoreV1Api()\n", + "# k8s_client.list_namespace(timeout_seconds=5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db3551a3", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import r2egym\n", + "\n", + "print(r2egym.__file__)\n", + "\n", + "try:\n", + " R2EGYM_PATH = os.path.dirname(r2egym.__file__)\n", + "except Exception:\n", + " R2EGYM_PATH = \"\"\n", + "\n", + "R2EGYM_COMMAND_FILES = [\n", + " os.path.join(R2EGYM_PATH, \"agenthub/tools/file_editor.py\"),\n", + " os.path.join(R2EGYM_PATH, \"agenthub/tools/search.py\"),\n", + " os.path.join(R2EGYM_PATH, \"agenthub/tools/execute_bash.py\"),\n", + " os.path.join(R2EGYM_PATH, \"agenthub/tools/finish.py\"),\n", + "]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db912576", + "metadata": {}, + "outputs": [], + "source": [ + "# from r2egym.agenthub.environment.env import EnvArgs, RepoEnv\n", + "\n", + "# env_args = EnvArgs(ds=entries[0])\n", + "# # Create a SandboxTemplate, SandboxClaim, Sandbox, and Pod\n", + "# env = RepoEnv(env_args, backend=\"kubernetes-sandbox\")\n", + "\n", + "# # Create a single Pod\n", + "# # env = RepoEnv(env_args, backend=\"kubernetes\")\n", + "\n", + "# env.add_commands(cmd_files=R2EGYM_COMMAND_FILES)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "453c301a", + "metadata": {}, + "outputs": [], + "source": [ + "# output, exit_code = env.runtime.run(\"ls -F /testbed\")\n", + "\n", + "# if exit_code == \"0\":\n", + "# print(\"Pod is responsive! Contents of /testbed:\")\n", + "# print(output)\n", + "# else:\n", + "# print(f\"Execution failed with error: {exit_code}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2bd49391", + "metadata": {}, + "outputs": [], + "source": [ + "# # Check that the tools loaded\n", + "# output, _ = env.runtime.run(\"ls -F /usr/local/bin/\")\n", + "# print(output)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e186bb9", + "metadata": {}, + "outputs": [], + "source": [ + "# # Test if the search tool is functional\n", + "# output, exit_code = env.runtime.run(\"search --help\")\n", + "# print(f\"Tool Exit Code: {exit_code}\")\n", + "# print(output)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f028333", + "metadata": {}, + "outputs": [], + "source": [ + "# # Check Python version and ability to import the codebase\n", + "# output, _ = env.runtime.run(\n", + "# \"python --version && python -c 'import Orange; print(\\\"Orange version:\\\", Orange.__version__)'\")\n", + "# print(output)\n", + "\n", + "# # Check the git state to ensure it's at the correct base commit\n", + "# output, _ = env.runtime.run(\"git rev-parse HEAD\")\n", + "# print(f\"Current commit in pod: {output.strip()}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8ea026b0", + "metadata": {}, + "outputs": [], + "source": [ + "# Get pod details from the Kubernetes API\n", + "def get_pods():\n", + "\n", + " pod_list = k8s_client.list_namespaced_pod(\"default\")\n", + " for pod in pod_list.items:\n", + " print(\"%s\\t%s\\t%s\" % (pod.metadata.name,\n", + " pod.status.phase,\n", + " pod.status.pod_ip))\n", + "\n", + "\n", + "get_pods()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f1233f7", + "metadata": {}, + "outputs": [], + "source": [ + "import re\n", + "\n", + "# Define LLM Output Parser for Mocks. Would need a more robust parser for prod.\n", + "\n", + "\n", + "def parse_action(llm_output: str) -> dict[str, str]:\n", + " \"\"\"\n", + " Parses XML-like format: value\n", + " Returns dict like {'command': 'view', 'path': '/testbed'}\n", + " \"\"\"\n", + " args = {}\n", + " # Regex captures the key inside and the value inside the tags\n", + " matches = re.findall(\n", + " r'(.*?)', llm_output, re.DOTALL)\n", + "\n", + " for key, value in matches:\n", + " args[key.strip()] = value.strip()\n", + "\n", + " # print(\"parse_action\", args)\n", + " return args" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "839e2b1e", + "metadata": {}, + "outputs": [], + "source": [ + "def execute_mock_action(env, action_str: str) -> tuple[str, str]:\n", + " \"\"\"\n", + " Maps parsed LLM actions to the corresponding tool execution command in the sandbox.\n", + " \"\"\"\n", + " args = parse_action(action_str)\n", + " command_type = args.get('command')\n", + "\n", + " if not command_type:\n", + " errorStr = f\"Error: No command found in mock response. Args: {args}\"\n", + " # Throw error if command not parsed.\n", + " return errorStr, \"1\"\n", + "\n", + " bash_cmd = \"\"\n", + "\n", + " # Handle File Editor Tool (file_editor.py)\n", + " if command_type in ['view', 'create', 'str_replace', 'insert', 'undo_edit']:\n", + " bash_cmd = f\"file_editor --path {args.get('path', '')}\"\n", + " if 'view_range' in args:\n", + " bash_cmd += f\" --view_range '{args['view_range']}'\"\n", + " if 'file_text' in args:\n", + " bash_cmd += f\" --file_text '{args['file_text'].replace(\"'\", \"'\\\\''\")}'\"\n", + " if 'old_str' in args:\n", + " bash_cmd += f\" --old_str '{args['old_str'].replace(\"'\", \"'\\\\''\")}'\"\n", + " if 'new_str' in args:\n", + " bash_cmd += f\" --new_str '{args['new_str'].replace(\"'\", \"'\\\\''\")}'\"\n", + " if 'insert_line' in args:\n", + " bash_cmd += f\" --insert_line {args['insert_line']}\"\n", + " bash_cmd += f\" {command_type}\"\n", + "\n", + " # Handle Search Tool (search.py)\n", + " elif command_type == 'search':\n", + " bash_cmd = f\"search --search_term '{args.get('search_term', '').replace(\"'\", \"'\\\\''\")}' --path '{args.get('path', '.')}'\"\n", + "\n", + " # Handle Execute Bash Tool (execute_bash.py)\n", + " elif command_type == 'execute_bash':\n", + " bash_cmd = f\"execute_bash '{args.get('bash_command', '').replace(\"'\", \"'\\\\''\")}'\"\n", + "\n", + " # Handle Finish/Submit Tool (finish.py)\n", + " elif command_type == 'submit':\n", + " bash_cmd = f\"finish submit --result '{args.get('result', '').replace(\"'\", \"'\\\\''\")}'\"\n", + "\n", + " else:\n", + " errorStr = f\"Unknown command: {command_type}\"\n", + " return errorStr, \"1\"\n", + "\n", + " # print(f\"Executing in Sandbox: {bash_cmd}\")\n", + " infra_file_logger.info(f\"Executing in Sandbox: {bash_cmd}\")\n", + " output, exit_code = env.runtime.run(bash_cmd)\n", + " # print(\n", + " # f\"--- Output (Exit: {exit_code}) ---\\n{output[:1000]}\\n----------------\")\n", + " infra_file_logger.info(f\"--- Output (Exit: {exit_code}) ---\\n{output}\\n----------------\")\n", + " return output, exit_code" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8cc39080", + "metadata": {}, + "outputs": [], + "source": [ + "mock_responses = [\n", + " # Test 1: View directory structure using file_editor\n", + " \"\"\"\n", + " \n", + " view\n", + " /testbed\n", + " \n", + " \"\"\",\n", + " # Test 2: Search for a specific term using search tool\n", + " \"\"\"\n", + " \n", + " search\n", + " Orange\n", + " /testbed\n", + " \n", + " \"\"\",\n", + " # Test 3: Create a new Python file using file_editor\n", + " \"\"\"\n", + " \n", + " create\n", + " /testbed/verify_sandbox.py\n", + " import os\\nprint(\"Sandbox Verification: SUCCESS\")\\nprint(f\"Working Directory: {os.getcwd()}\")\n", + " \n", + " \"\"\",\n", + " # Test 4: Execute the newly created file using execute_bash\n", + " \"\"\"\n", + " \n", + " execute_bash\n", + " python /testbed/verify_sandbox.py\n", + " \n", + " \"\"\",\n", + " # Test 5: Use str_replace to modify the file\n", + " \"\"\"\n", + " \n", + " str_replace\n", + " /testbed/verify_sandbox.py\n", + " Sandbox Verification: SUCCESS\n", + " Sandbox Verification: COMPLETED\n", + " \n", + " \"\"\",\n", + " # Test 6: Verify the edit by running it again\n", + " \"\"\"\n", + " \n", + " execute_bash\n", + " python /testbed/verify_sandbox.py\n", + " \n", + " \"\"\",\n", + " # Test 7: Use insert to add a line at a specific position\n", + " \"\"\"\n", + " \n", + " insert\n", + " /testbed/verify_sandbox.py\n", + " 1\n", + " import sys\n", + " \n", + " \"\"\",\n", + " # Test 8: Final submission signal using finish tool\n", + " \"\"\"\n", + " \n", + " submit\n", + " All tools verified successfully.\n", + " \n", + " \"\"\"\n", + "]\n", + "\n", + "# for i, response in enumerate(mock_responses):\n", + "# print(f\"\\n>>> Step {i+1} <<<\")\n", + "# execute_mock_action(env, response)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0f8c6516", + "metadata": {}, + "outputs": [], + "source": [ + "import asyncio\n", + "from r2egym.agenthub.environment.env import EnvArgs, RepoEnv\n", + "\n", + "async def run_agent_workflow(entry, task_id, semaphore, mock_responses):\n", + " \"\"\"\n", + " Executes tasks and returns a standardized result dict for summary reporting.\n", + " \"\"\"\n", + " result = {\"task_id\": task_id, \"status\": \"PENDING\", \"error\": \"\", \"failed_step\": -1}\n", + "\n", + " async with semaphore:\n", + " try:\n", + " # --- PHASE 1: Provisioning (Transient/Startup) ---\n", + " # Any failure here is likely a GKE/Controller timeout or resource issue.\n", + " env_args = EnvArgs(ds=entry)\n", + " env = await asyncio.to_thread(RepoEnv, env_args, backend=\"kubernetes-sandbox\", logger=infra_file_logger)\n", + "\n", + " try:\n", + " env.add_commands(cmd_files=R2EGYM_COMMAND_FILES)\n", + "\n", + " # --- PHASE 2: Execution (Actual Test Run) ---\n", + " # Failures here are due to arg parsing, tool logic, missing files, or bash errors.\n", + " for i, action_str in enumerate(mock_responses):\n", + " # execute_mock_action is called in a thread to keep loop responsive\n", + " output, exit_code = await asyncio.to_thread(execute_mock_action, env, action_str)\n", + "\n", + " if exit_code != \"0\":\n", + " result.update({\n", + " \"status\": \"TEST_FAILED\",\n", + " \"failed_step\": i + 1,\n", + " \"error\": f\"Step {i+1} failed with exit code {exit_code}. Output Snippet: {output[:200]}...\"\n", + " })\n", + " return result\n", + "\n", + " result[\"status\"] = \"SUCCESS\"\n", + "\n", + " finally:\n", + " # Ensure cleanup even if execution failed\n", + " # close() shuts down the SandboxClaim, Sandbox, and Pod\n", + " env.runtime.close()\n", + " # Shared Resource Cleanup (Deletes the Template for ALL runs using this image)\n", + " # For this dataset each run has a unique image and thus a unique SandboxTemplate\n", + " # so we can delete the template at the end of the run.\n", + " env.runtime.delete_template()\n", + "\n", + " except RuntimeError as e:\n", + " # RepoEnv raises RuntimeError on startup timeout\n", + " result.update({\"status\": \"PROVISION_FAILED\", \"error\": str(e)})\n", + " except Exception as e:\n", + " result.update({\"status\": \"CRITICAL_ERROR\", \"error\": f\"{type(e).__name__}: {str(e)}\"})\n", + "\n", + " return result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "939cf553", + "metadata": {}, + "outputs": [], + "source": [ + "async def run_multiple_tests(entries, mock_responses, max_concurrency=100):\n", + " semaphore = asyncio.Semaphore(max_concurrency)\n", + " tasks = []\n", + "\n", + " print(f\"Launching {len(entries)} tasks...\")\n", + " for i, entry in enumerate(entries):\n", + " task = asyncio.create_task(run_agent_workflow(entry, f\"task-{i}\", semaphore, mock_responses))\n", + " tasks.append(task)\n", + "\n", + " # Wait for all tasks and collect result dicts\n", + " results = await asyncio.gather(*tasks)\n", + "\n", + " # --- Print Summary Report ---\n", + " print(\"\\n\" + \"=\"*70)\n", + " print(\"FINAL TEST SUMMARY\")\n", + " print(\"=\"*70)\n", + "\n", + " summary = {\"SUCCESS\": 0, \"PROVISION_FAILED\": 0, \"TEST_FAILED\": 0, \"CRITICAL_ERROR\": 0}\n", + " for res in results:\n", + " summary[res[\"status\"]] += 1\n", + " if res[\"status\"] != \"SUCCESS\":\n", + " print(f\"[{res['task_id']}] {res['status']}: {res['error']} (Step: {res['failed_step']})\")\n", + "\n", + " print(\"-\"*70)\n", + " print(f\"Total: {len(results)} | Success: {summary['SUCCESS']} | Startup Failures: {summary['PROVISION_FAILED']} | Test Failures: {summary['TEST_FAILED']}\")\n", + " print(\"=\"*70)\n", + "\n", + "# To run:\n", + "# Adjust number of tasks in entries\n", + "await run_multiple_tests(entries[:100], mock_responses, max_concurrency=10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "779fb835", + "metadata": {}, + "outputs": [], + "source": [ + "# Close the runtime to delete the SandboxClaim, Sandbox, and Pod.\n", + "# env.runtime.close()\n", + "# print(\"Sandbox Claim deleted. Pod termination initiated.\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8b8e811c", + "metadata": {}, + "outputs": [], + "source": [ + "# Shared Resource Cleanup (Deletes the Template for ALL runs using this image)\n", + "# Run this only when you are done with all tasks for this Docker image.\n", + "# env.runtime.delete_template()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/qlora_llama3_gpu.ipynb b/examples/qlora_llama3_gpu.ipynb new file mode 100644 index 00000000..7fcd9bbb --- /dev/null +++ b/examples/qlora_llama3_gpu.ipynb @@ -0,0 +1,680 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "xvQWlinG9D24" + }, + "source": [ + "# Parameter-Efficient Fine-Tuning of Llama 3.1-8B with LoRA/QLoRA on NVIDIA GPUs using JAX and Tunix\n", + "\n", + "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/google/tunix/blob/main/examples/qlora_llama3_gpu.ipynb) [![Open in Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/google/tunix/blob/main/examples/qlora_llama3_gpu.ipynb) [![View on GitHub](https://img.shields.io/badge/GitHub-181717?style=flat&logo=github&logoColor=white)](https://github.com/google/tunix/blob/main/examples/qlora_llama3_gpu.ipynb)\n", + "\n", + "This tutorial walks you through parameter-efficient fine-tuning (PEFT) of Llama 3.1-8B using LoRA and QLoRA on NVIDIA GPUs with JAX, Tunix, and Qwix. Unlike full-parameter SFT, PEFT freezes the base model weights and trains only small adapter matrices, dramatically reducing memory requirements and training time while maintaining model quality.\n", + "\n", + "**What you'll do:**\n", + "1. Set up the environment and authenticate with Hugging Face\n", + "2. Load the Llama 3.1-8B base model and apply LoRA/QLoRA adapters\n", + "3. Prepare the UltraChat 200k dataset for instruction fine-tuning\n", + "4. Configure and run parameter-efficient fine-tuning\n", + "5. Visualize training metrics with TensorBoard\n", + "6. Run a quick inference sanity check\n", + "\n", + "## Preliminaries\n", + "\n", + "### Make sure you have supported hardware\n", + "\n", + "**Hardware requirements.** QLoRA with 4-bit quantization can fine-tune Llama 3.1-8B on a single GPU with **16 GB+ of VRAM**. For LoRA without quantization, 24 GB+ is recommended. Multiple GPUs enable larger batch sizes and faster training through data parallelism; on multi-GPU systems, the model is automatically sharded across devices using FSDP and tensor parallelism." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Hq8dftyo9D25" + }, + "outputs": [], + "source": [ + "!nvidia-smi" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cUjQZdn09D25" + }, + "source": [ + "### Set your Hugging Face token\n", + "\n", + "Create a [Hugging Face](https://huggingface.co/) access token in your Hugging Face account [settings](https://huggingface.co/settings/tokens), copy it, and paste it into the field below. This token is required to authenticate with the Hugging Face Hub and download the Llama 3.1 model and related assets; once saved, it will be reused by this environment for the rest of the tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "B3tA6_VZ9D25" + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "from ipywidgets import Password, Button, HBox, Output\n", + "from IPython.display import display\n", + "\n", + "try:\n", + " from huggingface_hub import whoami\n", + "except Exception:\n", + " from huggingface_hub import HfApi\n", + "\n", + "def _verify_token(token: str) -> str:\n", + " try:\n", + " return whoami(token=token).get(\"name\", \"unknown\")\n", + " except TypeError:\n", + " return HfApi(token=token).whoami().get(\"name\", \"unknown\")\n", + "\n", + "token_box = Password(description=\"HF Token:\", placeholder=\"paste your token here\", layout={\"width\": \"400px\"})\n", + "save_btn = Button(description=\"Save\", button_style=\"success\")\n", + "out = Output()\n", + "\n", + "def save_token(_):\n", + " out.clear_output()\n", + " with out:\n", + " existing = os.environ.get(\"HF_TOKEN\")\n", + " entered = token_box.value.strip()\n", + " if existing and not entered:\n", + " user = _verify_token(existing)\n", + " print(f\"Using existing HF_TOKEN. Logged in as: {user}\")\n", + " return\n", + " if not entered:\n", + " print(\"No HF token entered.\")\n", + " return\n", + " os.environ[\"HF_TOKEN\"] = entered\n", + " user = _verify_token(entered)\n", + " print(f\"Token saved. Logged in as: {user}\")\n", + "\n", + "save_btn.on_click(save_token)\n", + "display(HBox([token_box, save_btn]), out)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FeIltbKB9D25" + }, + "source": [ + "### Authenticate with Hugging Face\n", + "\n", + "Verify that your Hugging Face token is set and valid. If the token is missing, an error is raised immediately rather than failing silently during model download." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5zM4Hbqo9D25" + }, + "outputs": [], + "source": [ + "# Prefer environment variable if already set\n", + "\n", + "from huggingface_hub.v1.hf_api import whoami\n", + "HF_TOKEN = os.environ.get(\"HF_TOKEN\")\n", + "\n", + "if HF_TOKEN:\n", + " try:\n", + " user = whoami()[\"name\"]\n", + " print(f\"Authenticated with Hugging Face as: {user} (via HF_TOKEN env)\")\n", + " except Exception as e:\n", + " print(\"HF_TOKEN is set but authentication failed:\", e)\n", + "else:\n", + " raise RuntimeError(\n", + " \"HF_TOKEN is not set. Please create a Hugging Face access token \"\n", + " \"and export it as an environment variable.\"\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Tgyp9oZG9D26" + }, + "source": [ + "### Acquire permission to use the gated model\n", + "\n", + "Llama 3.1-8B is a gated model, so you must explicitly request access before it can be downloaded. Visit the [model page](https://huggingface.co/meta-llama/Llama-3.1-8B) on Hugging Face, log in with the same account linked to your access token, and click **Request access**. You'll need to agree to Meta's license terms; approval is usually granted quickly but is not automatic. Once approved, your Hugging Face token will authorize downloads transparently. If you skip this step, model downloads will fail even with a valid token." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pBDdFFp39D26" + }, + "source": [ + "### Set up the environment\n", + "\n", + "### Import dependencies\n", + "\n", + "Import the core libraries needed for training:\n", + "- **JAX/Flax**: High-performance ML framework with automatic differentiation and XLA compilation\n", + "- **Optax**: Gradient processing and optimization library for JAX\n", + "- **Transformers**: Hugging Face library for tokenizers and model configurations\n", + "- **Qwix**: Quantization and LoRA utilities for JAX models\n", + "- **Tunix**: Training utilities including `PeftTrainer` and `AutoModel` for streamlined fine-tuning\n", + "\n", + "The easiest way to get a working environment is the [NVIDIA NGC JAX container](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/jax), which ships with all dependencies preinstalled. To install the dependencies manually:\n", + "\n", + "```bash\n", + "pip install 'jax[cuda13]' flax optax transformers datasets qwix\n", + "```\n", + "\n", + "On top of the installation (either container or manual), you will need Tunix:\n", + "\n", + "```bash\n", + "pip install tunix\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "4Mmk-LGe9D26" + }, + "outputs": [], + "source": [ + "# Imports\n", + "import time\n", + "import shutil\n", + "import numpy as np\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import optax\n", + "from flax import nnx\n", + "import transformers\n", + "from datasets import load_dataset\n", + "\n", + "import qwix\n", + "from tunix.models.automodel import AutoModel\n", + "from tunix.sft import peft_trainer, metrics_logger\n", + "\n", + "print(f\"JAX {jax.__version__} | Devices: {jax.devices()}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fz9sizzf9D26" + }, + "source": [ + "### Create the device mesh\n", + "\n", + "JAX uses a device mesh to define how computation and data are distributed across GPUs. The mesh assigns logical axis names to physical device dimensions, enabling FSDP (Fully Sharded Data Parallel) and TP (Tensor Parallel) strategies. The configuration adapts automatically based on available GPUs:\n", + "\n", + "| GPUs | Mesh Shape | Strategy |\n", + "|------|------------|----------|\n", + "| 8+ | `(1, 4, 2)` | data + FSDP + TP |\n", + "| 2–7 | `(N, 1)` | FSDP only |\n", + "| 1 | `(1, 1)` | No sharding |\n", + "\n", + "The `fsdp` axis shards model parameters across devices to reduce per-device memory, while `tp` enables tensor-parallel splitting of large weight matrices." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "pIjUzsbH9D26" + }, + "outputs": [], + "source": [ + "# Create mesh for sharding\n", + "NUM_DEVICES = jax.local_device_count()\n", + "\n", + "if NUM_DEVICES >= 8:\n", + " mesh = jax.make_mesh((1, 4, 2), (\"data\", \"fsdp\", \"tp\"),\n", + " axis_types=(jax.sharding.AxisType.Auto,) * 3)\n", + "elif NUM_DEVICES >= 2:\n", + " # Shard model across GPUs using FSDP\n", + " mesh = jax.make_mesh((NUM_DEVICES, 1), (\"fsdp\", \"tp\"),\n", + " axis_types=(jax.sharding.AxisType.Auto,) * 2)\n", + "else:\n", + " # Single GPU - no sharding, but keep axis names for API consistency\n", + " mesh = jax.make_mesh((1, 1), (\"fsdp\", \"tp\"),\n", + " axis_types=(jax.sharding.AxisType.Auto,) * 2)\n", + "\n", + "print(f\"Devices: {NUM_DEVICES} | Mesh: {mesh.shape}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lKRr2NLd9D27" + }, + "source": [ + "## Define model and training parameters\n", + "\n", + "All training hyperparameters are defined in one place for easy experimentation. The key parameters control model selection, LoRA configuration, quantization, batch size, sequence length, and training duration. Set `CLEAN_START = True` to remove existing checkpoints before training, or `False` to resume from a previous run." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "3WkC8SGk9D27" + }, + "outputs": [], + "source": [ + "# Configuration\n", + "os.environ[\"TF_CPP_MIN_LOG_LEVEL\"] = \"2\" # Suppress CUDA/TF warnings\n", + "\n", + "MODEL_ID = \"meta-llama/Llama-3.1-8B\"\n", + "TOKENIZER_ID = \"meta-llama/Llama-3.1-8B-Instruct\"\n", + "\n", + "LORA_RANK = 16\n", + "LORA_ALPHA = 32.0\n", + "USE_QUANTIZATION = True # set True for QLoRA (4-bit), set False for regular LoRA\n", + "\n", + "BATCH_SIZE = 2\n", + "MAX_SEQ_LENGTH = 512\n", + "LEARNING_RATE = 1e-4\n", + "MAX_STEPS = 100\n", + "\n", + "OUTPUT_DIR = \"/workspace/llama3_lora_output\"\n", + "CLEAN_START = True # Set to False to resume from checkpoint\n", + "\n", + "if CLEAN_START and os.path.exists(f\"{OUTPUT_DIR}/checkpoints\"):\n", + " shutil.rmtree(f\"{OUTPUT_DIR}/checkpoints\")\n", + " print(\"Removed old checkpoints (CLEAN_START=True)\")\n", + "\n", + "os.makedirs(OUTPUT_DIR, exist_ok=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zcKtJRBn9D27" + }, + "source": [ + "## Load the model\n", + "\n", + "### Load the tokenizer\n", + "\n", + "Load the tokenizer from the Instruct model variant, which includes the chat template for formatting conversations. The pad token is set to the EOS token if not already defined, which is standard for decoder-only models like Llama." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8D7BAvQm9D27" + }, + "outputs": [], + "source": [ + "# Load tokenizer\n", + "tokenizer = transformers.AutoTokenizer.from_pretrained(TOKENIZER_ID, token=HF_TOKEN)\n", + "tokenizer.pad_token = tokenizer.pad_token or tokenizer.eos_token\n", + "print(f\"Tokenizer loaded: {TOKENIZER_ID}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jDq9ya169D27" + }, + "source": [ + "### Load the base model\n", + "\n", + "`AutoModel.from_pretrained()` handles the complete model loading pipeline: downloading weights from the Hugging Face Hub (cached in `model_download_path`), converting them to JAX-compatible format, and initializing the model architecture with proper sharding across the mesh.\n", + "\n", + "The model is loaded within the mesh context to ensure parameters are distributed correctly across devices from the start." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OY6G3z6q9D27" + }, + "outputs": [], + "source": [ + "# Load model using AutoModel\n", + "print(f\"Loading {MODEL_ID}...\")\n", + "load_start = time.time()\n", + "\n", + "with mesh:\n", + " base_model, model_path = AutoModel.from_pretrained(\n", + " MODEL_ID,\n", + " mesh,\n", + " model_download_path=\"/hf_cache\",\n", + " )\n", + "\n", + "print(f\"Model loaded in {time.time() - load_start:.1f}s\")\n", + "print(f\"Model path: {model_path}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GUI18KNI9D27" + }, + "source": [ + "## Apply LoRA / QLoRA\n", + "\n", + "Low-Rank Adaptation (LoRA) freezes the base model weights and injects small trainable matrices into attention and MLP layers. This dramatically reduces the number of trainable parameters while preserving model quality.\n", + "\n", + "**QLoRA** adds 4-bit NF4 quantization on top of LoRA to further reduce memory:\n", + "- Base weights are quantized to 4-bit NormalFloat format\n", + "- Only the small LoRA adapter weights remain in full precision\n", + "- `tile_size=32` controls the quantization block size (must divide the smallest weight dimension)\n", + "\n", + "**Target modules** specify which layers receive LoRA adapters using regex patterns matching attention projections (`q_proj`, `k_proj`, `v_proj`, `o_proj`) and MLP layers (`gate_proj`, `up_proj`, `down_proj`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "oGF2AwBb9D27" + }, + "outputs": [], + "source": [ + "# Apply QLoRA / LoRA\n", + "target_modules = \".*q_proj|.*k_proj|.*v_proj|.*o_proj|.*gate_proj|.*up_proj|.*down_proj\"\n", + "\n", + "lora_provider = qwix.LoraProvider(\n", + " module_path=target_modules,\n", + " rank=LORA_RANK,\n", + " alpha=LORA_ALPHA,\n", + " weight_qtype=\"nf4\" if USE_QUANTIZATION else None,\n", + " tile_size=32 if USE_QUANTIZATION else None,\n", + ")\n", + "\n", + "dummy_input = {\n", + " 'input_tokens': jnp.ones((1, 128), dtype=jnp.int32),\n", + " 'positions': jnp.arange(128)[None, :],\n", + " 'cache': None,\n", + " 'attention_mask': jnp.ones((1, 128, 128), dtype=jnp.bool_),\n", + "}\n", + "\n", + "print(f\"Applying {'QLoRA' if USE_QUANTIZATION else 'LoRA'} (rank={LORA_RANK})...\")\n", + "lora_model = qwix.apply_lora_to_model(\n", + " base_model, lora_provider,\n", + " rngs=nnx.Rngs(params=0), # For reproducible LoRA weight initialization\n", + " **dummy_input\n", + ")\n", + "\n", + "with mesh:\n", + " state = nnx.state(lora_model)\n", + " sharded = jax.lax.with_sharding_constraint(state, nnx.get_partition_spec(state))\n", + " nnx.update(lora_model, sharded)\n", + "\n", + "print(f\"{'QLoRA' if USE_QUANTIZATION else 'LoRA'} applied!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "RUdjvwH79D27" + }, + "source": [ + "## Prepare the training data\n", + "\n", + "Load the [UltraChat 200k](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k) dataset, a large collection of multi-turn conversations commonly used for instruction fine-tuning. For this tutorial, a subset of 2,000 training and 200 evaluation examples is used.\n", + "\n", + "The data processing pipeline applies the chat template to format conversations with special tokens, tokenizes with padding to `MAX_SEQ_LENGTH`, and creates attention masks to ignore padding tokens. Training uses an infinite generator that cycles through the data, while evaluation uses a finite iterator that yields exactly one pass through the eval set. Batch size is scaled by `NUM_DEVICES` for data parallelism." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NcecSYUs9D27" + }, + "outputs": [], + "source": [ + "# Prepare dataset\n", + "dataset = load_dataset(\"HuggingFaceH4/ultrachat_200k\", split=\"train_sft\").select(range(2000))\n", + "eval_dataset = load_dataset(\"HuggingFaceH4/ultrachat_200k\", split=\"test_sft\").select(range(200))\n", + "\n", + "def tokenize(ex):\n", + " text = tokenizer.apply_chat_template(ex[\"messages\"], tokenize=False)\n", + " tok = tokenizer(text, max_length=MAX_SEQ_LENGTH, padding=\"max_length\", truncation=True)\n", + " return {\"input_tokens\": np.array(tok[\"input_ids\"]), \"input_mask\": np.array(tok[\"attention_mask\"], dtype=bool)}\n", + "\n", + "train_data = [tokenize(ex) for ex in dataset]\n", + "eval_data = [tokenize(ex) for ex in eval_dataset]\n", + "\n", + "# Infinite generator for training (cycles through data)\n", + "def train_batches(data, bs):\n", + " i = 0\n", + " while True:\n", + " batch = data[i:i+bs] if i+bs <= len(data) else data[:bs]\n", + " yield {k: np.stack([x[k] for x in batch]) for k in batch[0]}\n", + " i = (i + bs) % len(data)\n", + "\n", + "# Reusable eval dataset - returns fresh finite iterator each time\n", + "class EvalDataset:\n", + " def __init__(self, data, bs):\n", + " self.data = data\n", + " self.bs = bs\n", + " def __iter__(self):\n", + " for i in range(0, len(self.data), self.bs):\n", + " batch = self.data[i:i+self.bs]\n", + " if len(batch) == self.bs:\n", + " yield {k: np.stack([x[k] for x in batch]) for k in batch[0]}\n", + "\n", + "train_ds = train_batches(train_data, BATCH_SIZE * NUM_DEVICES)\n", + "eval_ds = EvalDataset(eval_data, BATCH_SIZE * NUM_DEVICES)\n", + "\n", + "print(f\"Train: {len(train_data)} examples | Eval: {len(eval_data)} examples | Batch size: {BATCH_SIZE * NUM_DEVICES}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7ToTGxuf9D27" + }, + "source": [ + "## Provide the training configuration\n", + "\n", + "The model expects specific input formats: position indices for rotary embeddings and a 3D causal attention mask `[batch, seq, seq]` combining causal attention with padding. The `gen_model_input` function constructs these from the tokenized batch.\n", + "\n", + "`PeftTrainer` orchestrates the training loop with an AdamW optimizer, periodic checkpointing, TensorBoard-compatible metrics logging, and evaluation every `eval_every_n_steps` steps." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rRmCedfn9D27" + }, + "outputs": [], + "source": [ + "# Input processing helpers\n", + "def build_positions(mask):\n", + " return jnp.clip(jnp.cumsum(mask, axis=-1) - 1, 0).astype(jnp.int32)\n", + "\n", + "def build_causal_mask(mask):\n", + " n = mask.shape[-1]\n", + " return jnp.tril(jnp.ones((n, n), dtype=jnp.bool_))[None] & mask[:, None, :]\n", + "\n", + "def gen_model_input(x):\n", + " mask = x[\"input_tokens\"] != tokenizer.pad_token_id\n", + " return {\n", + " \"input_tokens\": x[\"input_tokens\"],\n", + " \"positions\": build_positions(mask),\n", + " \"attention_mask\": build_causal_mask(mask),\n", + " \"input_mask\": x[\"input_mask\"],\n", + " }\n", + "\n", + "# Create trainer\n", + "trainer = peft_trainer.PeftTrainer(\n", + " lora_model,\n", + " optax.adamw(LEARNING_RATE),\n", + " peft_trainer.TrainingConfig(\n", + " max_steps=MAX_STEPS,\n", + " eval_every_n_steps=25, # Evaluate every 25 steps\n", + " checkpoint_root_directory=f\"{OUTPUT_DIR}/checkpoints\",\n", + " metrics_logging_options=metrics_logger.MetricsLoggerOptions(log_dir=f\"{OUTPUT_DIR}/logs\"),\n", + " ),\n", + ").with_gen_model_input_fn(gen_model_input)\n", + "\n", + "print(\"Trainer ready!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1e7VliKg9D27" + }, + "source": [ + "## Run the training\n", + "\n", + "This block launches the PEFT training loop. It runs a baseline evaluation first to measure initial loss, then trains for `MAX_STEPS` steps with periodic evaluation. The first step is slower due to XLA JIT compilation, which is cached for subsequent steps." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "r5A9rgSC9D27" + }, + "outputs": [], + "source": [ + "# Training with progress\n", + "NUM_EVAL_BATCHES = len(eval_data) // (BATCH_SIZE * NUM_DEVICES)\n", + "\n", + "class Progress:\n", + " def __init__(self, n): \n", + " self.n = n\n", + " self.t0 = None\n", + " self.eval_count = 0\n", + " self.eval_started = False\n", + " def on_train_start(self, _): \n", + " self.t0 = time.time()\n", + " print(\"Training (first step includes JIT)...\")\n", + " def on_train_end(self, _): \n", + " print(f\"\\nDone in {time.time()-self.t0:.0f}s\")\n", + " def on_train_step_start(self, _): \n", + " self.eval_started = False\n", + " def on_train_step_end(self, _, step, loss, dt):\n", + " if step <= 2 or step % 10 == 0:\n", + " print(f\"Step {step}/{self.n} | Loss: {float(loss):.4f} | {dt:.1f}s/step\")\n", + " def on_eval_step_start(self, _):\n", + " if not self.eval_started:\n", + " self.eval_count += 1\n", + " label = \"Baseline eval\" if self.eval_count == 1 else f\"Eval #{self.eval_count}\"\n", + " print(f\"{label}...\", end=\" \", flush=True)\n", + " self.eval_started = True\n", + " def on_eval_step_end(self, _, eval_loss):\n", + " avg_loss = float(eval_loss) / NUM_EVAL_BATCHES\n", + " print(f\"loss: {avg_loss:.4f} (avg over {NUM_EVAL_BATCHES} batches)\")\n", + "\n", + "trainer.training_hooks = Progress(MAX_STEPS)\n", + "\n", + "print(\"Starting (baseline eval + JIT compilation first)...\")\n", + "with mesh:\n", + " trainer.train(train_ds, eval_ds)\n", + "\n", + "print(f\"Checkpoints: {OUTPUT_DIR}/checkpoints\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mnh044BT9D27" + }, + "source": [ + "### Visualize training with TensorBoard\n", + "\n", + "To monitor training loss and other metrics, launch TensorBoard in a separate terminal:\n", + "\n", + "```bash\n", + "tensorboard --logdir=/workspace/llama3_lora_output/logs --host 0.0.0.0 --port 6006 --load_fast=false\n", + "```\n", + "\n", + "Then open [http://127.0.0.1:6006/](http://127.0.0.1:6006/) in your browser." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xpOAsdXX9D27" + }, + "source": [ + "## Test inference\n", + "\n", + "A quick sanity check to verify the fine-tuned model produces coherent output. The code below tokenizes a prompt using the Llama 3.1 chat template, then runs greedy autoregressive generation for up to 10 tokens, stopping early if the model produces an EOS token. This confirms the adapters are applied correctly and the model produces reasonable predictions.\n", + "\n", + "Note: this is naive autoregressive generation without KV-caching, so each step recomputes attention over the full sequence. For production use, consider a dedicated serving framework with KV-cache support." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "KF903NJa9D27" + }, + "outputs": [], + "source": [ + "# Quick inference test with the fine-tuned LoRA model\n", + "prompt = \"What is the capital of France?\"\n", + "messages = [{\"role\": \"user\", \"content\": prompt}]\n", + "text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)\n", + "\n", + "# Tokenize\n", + "tokens = jnp.array(tokenizer(text)[\"input_ids\"])[None, :]\n", + "\n", + "# Greedy autoregressive generation\n", + "max_new_tokens = 10\n", + "generated_ids = []\n", + "eos_token_id = tokenizer.eos_token_id\n", + "\n", + "for _ in range(max_new_tokens):\n", + " seq_len = tokens.shape[1]\n", + " positions = jnp.arange(seq_len)[None, :]\n", + " attention_mask = jnp.tril(jnp.ones((seq_len, seq_len), dtype=jnp.bool_))[None, :]\n", + "\n", + " with mesh:\n", + " output = lora_model(tokens, positions, None, attention_mask)\n", + " logits = output[0] if isinstance(output, tuple) else output\n", + "\n", + " next_token_id = int(jnp.argmax(logits[0, -1]))\n", + " generated_ids.append(next_token_id)\n", + "\n", + " if next_token_id == eos_token_id:\n", + " break\n", + "\n", + " tokens = jnp.concatenate([tokens, jnp.array([[next_token_id]])], axis=1)\n", + "\n", + "# Decode all generated tokens\n", + "generated_text = tokenizer.decode(generated_ids, skip_special_tokens=True)\n", + "\n", + "print(f\"Prompt: {prompt}\")\n", + "print(f\"Generated ({len(generated_ids)} tokens): '{generated_text}'\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/rl/grpo/gsm8k/configs/gemma2_2b.yaml b/examples/rl/grpo/gsm8k/configs/gemma2_2b.yaml index 91f50621..95168562 100644 --- a/examples/rl/grpo/gsm8k/configs/gemma2_2b.yaml +++ b/examples/rl/grpo/gsm8k/configs/gemma2_2b.yaml @@ -13,8 +13,8 @@ # limitations under the License. model_config: - model_name: "gemma-2-2b-it" - model_id: "google/gemma-2-2b-it" + model_name: "gemma2_2b_it" + model_id: "gemma2_2b_it" model_path: "google/gemma-2/flax/gemma2-2b-it" model_source: "kaggle" mesh: diff --git a/examples/rl/grpo/gsm8k/run_gemma_7b.sh b/examples/rl/grpo/gsm8k/run_gemma_7b.sh index 1e1f365d..9cda82a6 100755 --- a/examples/rl/grpo/gsm8k/run_gemma_7b.sh +++ b/examples/rl/grpo/gsm8k/run_gemma_7b.sh @@ -41,8 +41,8 @@ echo "Rounded warmup steps: $warmup_steps" python3 -m tunix.cli.grpo_main \ base_config.yaml \ - model_config.model_name="gemma-7b-it" \ - model_config.model_id="google/gemma-7b-it" \ + model_config.model_name="gemma_7b_it" \ + model_config.model_id="gemma_7b_it" \ model_config.model_path="google/gemma/flax/7b-it" \ model_config.model_source="kaggle" \ model_config.model_download_path="/tmp/models/gemma-7b" \ diff --git a/examples/sft/mtnt/configs/gemma2_2b.yaml b/examples/sft/mtnt/configs/gemma2_2b.yaml index 2b6b6bba..a0744462 100644 --- a/examples/sft/mtnt/configs/gemma2_2b.yaml +++ b/examples/sft/mtnt/configs/gemma2_2b.yaml @@ -13,8 +13,8 @@ # limitations under the License. model_config: - model_name: "gemma-2-2b-it" - model_id: "google/gemma-2-2b-it" + model_name: "gemma2_2b_it" + model_id: "gemma2_2b_it" model_path: "google/gemma-2/flax/gemma2-2b-it" model_source: "kaggle" mesh: diff --git a/examples/sft/mtnt/run_gemma_2b.sh b/examples/sft/mtnt/run_gemma_2b.sh index d471aa9a..609ca5bf 100755 --- a/examples/sft/mtnt/run_gemma_2b.sh +++ b/examples/sft/mtnt/run_gemma_2b.sh @@ -17,8 +17,8 @@ set -x # Enable xtrace python3 -m tunix.cli.peft_main \ base_config.yaml \ - model_config.model_name="gemma-2b" \ - model_config.model_id="google/gemma-2b" \ + model_config.model_name="gemma_2b" \ + model_config.model_id="gemma_2b" \ model_config.model_path="google/gemma/flax/2b" \ model_config.model_source="kaggle" \ model_config.model_download_path="/tmp/models" \ diff --git a/pyproject.toml b/pyproject.toml index d3c296f5..c9745031 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -55,7 +55,7 @@ docs = [ "sphinx_contributors", ] prod = [ - "jax[tpu]>=0.6.0,!=0.7.2, <=0.8.1", # Jax 0.7.2 has performance regression on OSS + "jax[tpu]>=0.6.0,!=0.7.2", # Jax 0.7.2 has performance regression on OSS ] dev = [ # Manully install vLLM & tpu-inferece, which depends on jax[tpu]==0.7.2 diff --git a/tests/cli/config_test.py b/tests/cli/config_test.py index 48bf096e..66627610 100644 --- a/tests/cli/config_test.py +++ b/tests/cli/config_test.py @@ -118,15 +118,16 @@ def test_override_training_config_simple(self): self.run_test_peft_trainer(hp) def test_override_training_config_complex(self): - argv = [ - "", - "base_config.yaml", - "training_config.profiler_options.log_dir=/tmp/profiler_log_dir", - "training_config.profiler_options.skip_first_n_steps=1", - "training_config.profiler_options.profiler_steps=5", - "training_config.eval_every_n_steps=10", - ] - self.run_test_peft_trainer(config.initialize(argv)) + with tempfile.TemporaryDirectory() as log_dir: + argv = [ + "", + "base_config.yaml", + f"training_config.profiler_options.log_dir={log_dir}", + "training_config.profiler_options.skip_first_n_steps=1", + "training_config.profiler_options.profiler_steps=5", + "training_config.eval_every_n_steps=10", + ] + self.run_test_peft_trainer(config.initialize(argv)) @parameterized.named_parameters( dict( @@ -545,49 +546,55 @@ def test_model_config_inheritance(self): hp3.config["reference_model_config"]["model_name"], "gemma3-4b" ) - def test_perf_metrics_validation_grpo_enabled(self): - # Enable perf metrics in grpo_main -> Should succeed - argv = [ - "grpo_main", - "base_config.yaml", - "training_config.perf_metrics_options.enable_perf_metrics=True", - ] - config.initialize(argv) - - def test_perf_metrics_validation_peft_enabled_fails(self): - # Enable perf metrics in peft_main -> Should fail - argv = [ - "peft_main", - "base_config.yaml", - "training_config.perf_metrics_options.enable_perf_metrics=True", - ] - with self.assertRaisesRegex( - ValueError, - "Perf metrics are currently only supported for GRPO training", - ): - config.initialize(argv) - - def test_perf_metrics_validation_peft_disabled(self): - # Disable perf metrics in peft_main -> Should succeed - argv = [ - "peft_main", - "base_config.yaml", - "training_config.perf_metrics_options.enable_perf_metrics=False", - ] - config.initialize(argv) - - def test_perf_metrics_validation_invalid_custom_export_fn_path(self): - argv = [ - "grpo_main", - "base_config.yaml", - "training_config.perf_metrics_options.enable_perf_metrics=True", - "training_config.perf_metrics_options.custom_export_fn_path=invalid.path", - ] - with self.assertRaisesRegex( - ValueError, - "Could not load custom export function from invalid.path", - ): - config.initialize(argv) + @parameterized.named_parameters( + dict( + testcase_name="grpo_enabled", + main_command="grpo_main", + overrides=[ + "training_config.perf_metrics_options.log_dir={log_dir}", + ], + ), + dict( + testcase_name="peft_enabled_fails", + main_command="peft_main", + overrides=[ + "training_config.perf_metrics_options.log_dir={log_dir}", + ], + expected_error=ValueError, + error_regex=( + "Perf metrics are currently only supported for GRPO training" + ), + ), + dict( + testcase_name="peft_disabled", + main_command="peft_main", + overrides=[], + ), + dict( + testcase_name="invalid_custom_export_fn_path", + main_command="grpo_main", + overrides=[ + "training_config.perf_metrics_options.custom_export_fn_path=invalid.path", + ], + expected_error=ValueError, + error_regex="Could not load custom export function from invalid.path", + ), + ) + def test_perf_metrics_validation( + self, + main_command, + overrides, + expected_error=None, + error_regex=None, + ): + with tempfile.TemporaryDirectory() as log_dir: + overrides = [o.format(log_dir=log_dir) for o in overrides] + argv = [main_command, "base_config.yaml"] + overrides + if expected_error: + with self.assertRaisesRegex(expected_error, error_regex): + config.initialize(argv) + else: + config.initialize(argv) if __name__ == "__main__": diff --git a/tests/generate/sampler_test.py b/tests/generate/sampler_test.py index c34654c4..3273e147 100644 --- a/tests/generate/sampler_test.py +++ b/tests/generate/sampler_test.py @@ -418,6 +418,41 @@ def test_eos_tokens(self): result.tokens, [np.array([14]), np.array([12, 1, 17])] ) + def test_forbidden_token_ids(self): + vocab = tc.MockVocab() + transformer = tc.ToyTransformer( + config=tc.ModelConfig(vocab_size=vocab.GetPieceSize()), + rngs=nnx.Rngs(42), + ) + sampler = sampler_lib.Sampler( + transformer=transformer, + tokenizer=vocab, + cache_config=sampler_lib.CacheConfig( + cache_size=128, + num_layers=4, + num_kv_heads=4, + head_dim=16, + ), + ) + + vocab_size = vocab.GetPieceSize() + num_allowed_tokens = vocab_size // 4 + forbidden_tokens = set(range(num_allowed_tokens, vocab_size)) + # EOS is forbidden so we are sure to get a full length generation. + forbidden_tokens.add(vocab.eos_id()) + max_generation_steps = 100 + + result = sampler( + ['input string'], + max_generation_steps=max_generation_steps, + return_logits=False, + forbidden_tokens=forbidden_tokens, + temperature=1.0, # Ensure some randomness + seed=123, + ) + self.assertLen(result.tokens[0], max_generation_steps) + self.assertNoCommonElements(result.tokens[0], forbidden_tokens) + if __name__ == '__main__': absltest.main() diff --git a/tests/generate/sglang_jax_sampler_test.py b/tests/generate/sglang_jax_sampler_test.py index c8b9451a..4a36f70f 100644 --- a/tests/generate/sglang_jax_sampler_test.py +++ b/tests/generate/sglang_jax_sampler_test.py @@ -129,6 +129,8 @@ def test_sglang_jax_sampler(self): sgl_sampler = sglang_jax_sampler.SglangJaxSampler( tokenizer=model_tokenizer, config=sglang_jax_config, + # Test kwargs forwarding + disable_precompile=False, ) self.assertNotEqual(sgl_sampler.mesh, self.mesh) state = nnx.state(tunix_model) diff --git a/tests/generate/utils_test.py b/tests/generate/utils_test.py index f1e06622..2d19d3e8 100644 --- a/tests/generate/utils_test.py +++ b/tests/generate/utils_test.py @@ -14,6 +14,7 @@ # limitations under the License. from absl.testing import parameterized +from absl.testing import absltest from flax import nnx import jax from jax import sharding @@ -170,7 +171,8 @@ def test_logprobs_empty_cases(self, token_ids, logprobs): def test_transfer_state_with_mappings_tranpose_and_sharding_device(self): device_count = len(jax.devices()) - assert device_count % 2 == 0, "This example assumes even number of devices" + if device_count < 2 or device_count % 2 != 0: + self.skipTest("This example assumes even number of devices >= 2") devices_array = np.array(jax.devices()).reshape((device_count // 2, 2)) mesh = Mesh(devices_array, axis_names=("data", "model")) @@ -276,6 +278,24 @@ def test_transfer_state_with_padding(self): ) ) + def test_transfer_state_with_bias_padding_and_reshape(self): + """Test rank mismatch, reshape and padding for attention bias.""" + src_key = "layers.0.attn.q_bias" + src_q_bias = jnp.ones((256,), dtype=jnp.float32) + src = MockState({src_key: MockParam(src_q_bias)}) + dst = MockState( + {src_key: MockParam(jnp.zeros((4, 128), dtype=jnp.float32))} + ) + + mappings = {src_key: (src_key, None)} + + result = utils.transfer_state_with_mappings(src, dst, mappings) + + # Verify shape + self.assertEqual(result.params[src_key].shape, (4, 128)) + # Verify values are repeated correctly + self.assertTrue(jnp.allclose(result.params[src_key], 1.0)) + def test_transfer_state_with_scanned_layers(self): """Comprehensive test for scanned layers covering multiple scenarios.""" num_layers = 3 @@ -818,14 +838,13 @@ def test_transfer_state_directly_intersects_keys(self): self.assertFalse(hasattr(dst_state_mixed['decoder'], 'layer1')) def test_transfer_state_directly_with_plain_dicts(self): - """Tests transfer with plain dicts, nnx.State, and various variables.""" + """Tests transfer with plain dicts and various variables.""" src_state = { 'decoder': { - 'layer0': - nnx.State({ + 'layer0': { 'weight': nnx.Param(jnp.array(1.0)), 'some_variable': nnx.Variable(jnp.array([1, 2])), - }), + }, 'extra_layer': { 'sub': { 'value': nnx.Param(jnp.array(3.0)) @@ -836,11 +855,10 @@ def test_transfer_state_directly_with_plain_dicts(self): } dst_state = { 'decoder': { - 'layer0': - nnx.State({ + 'layer0': { 'weight': nnx.Param(jnp.array(0.0)), 'some_variable': nnx.Variable(jnp.array([0, 0])), - }), + }, 'layer1': { 'weight': nnx.Param(jnp.array(0.0)) }, # untouched @@ -1006,3 +1024,166 @@ def test_transfer_state_with_interleaved_scanned_layers(self): ), "Non-interleaved layer 3 should be zero", ) + + def test_transfer_state_directly_scanned_layers(self): + """Tests transfer from scanned 'layers' in source to 'layers_X' in dest.""" + # Source has 'layers' containing stacked weights (shape (2, ...)) + src_state = nnx.Dict( + base=nnx.Dict( + decoder=nnx.Dict( + layers=nnx.Dict( + mlp=nnx.Dict( + # Stacked weight for 2 layers: 0->10.0, 1->20.0 + weight=nnx.Param(jnp.array([10.0, 20.0])) + ) + ) + ) + ) + ) + # Dest has 'layers_0', 'layers_1' unrolled + dst_state = nnx.Dict( + model=nnx.Dict( + decoder=nnx.Dict( + layers_0=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.array(0.0)))), + layers_1=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.array(0.0)))), + ) + ) + ) + + mock_reshard = lambda source, target: source + utils.transfer_state_directly(src_state, dst_state, reshard_fn=mock_reshard) + + np.testing.assert_array_equal( + dst_state['model']['decoder']['layers_0']['mlp']['weight'][...], # Use [...] + jnp.array(10.0), + ) + np.testing.assert_array_equal( + dst_state['model']['decoder']['layers_1']['mlp']['weight'][...], # Use [...] + jnp.array(20.0), + ) + + def test_transfer_state_directly_implicit_layers_container(self): + """Tests transfer when source IS the layers container (GPT-OSS style).""" + # Use nnx.Dict for consistency + src_state = nnx.Dict( + layers=nnx.Dict( + mlp=nnx.Dict(weight=nnx.Param(jnp.array([100.0, 200.0]))) + ) + ) + + dst_state = nnx.Dict( + layers=nnx.Dict( + layers_0=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.array(0.0)))), + layers_1=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.array(0.0)))), + ) + ) + + mock_reshard = lambda source, target: source + utils.transfer_state_directly(src_state, dst_state, reshard_fn=mock_reshard) + + np.testing.assert_array_equal( + dst_state['layers']['layers_0']['mlp']['weight'][...], + jnp.array(100.0), + ) + np.testing.assert_array_equal( + dst_state['layers']['layers_1']['mlp']['weight'][...], + jnp.array(200.0), + ) + + def test_transfer_state_directly_with_dtype_casting(self): + """Tests that transfer_state_directly correctly casts dtypes (e.g., f32 to bf16).""" + # Source state in float32 + src_state = nnx.Dict( + decoder=nnx.Dict( + layer0=nnx.Dict( + weight=nnx.Param(jnp.array([1.0, 2.0, 3.0], dtype=jnp.float32)) + ), + # Scanned layers in float32 + layers=nnx.Dict( + mlp=nnx.Dict( + weight=nnx.Param(jnp.array([[10.0, 11.0], [20.0, 21.0]], dtype=jnp.float32)) + ) + ) + ) + ) + + # Destination state in bfloat16 + dst_state = nnx.Dict( + decoder=nnx.Dict( + layer0=nnx.Dict( + weight=nnx.Param(jnp.zeros((3,), dtype=jnp.bfloat16)) + ), + # Unrolled layers in bfloat16 + layers_0=nnx.Dict( + mlp=nnx.Dict(weight=nnx.Param(jnp.zeros((2,), dtype=jnp.bfloat16))) + ), + layers_1=nnx.Dict( + mlp=nnx.Dict(weight=nnx.Param(jnp.zeros((2,), dtype=jnp.bfloat16))) + ) + ) + ) + + mock_reshard = lambda source, target: source + utils.transfer_state_directly(src_state, dst_state, reshard_fn=mock_reshard) + + # Verify direct mapping cast + self.assertEqual(dst_state['decoder']['layer0']['weight'].dtype, jnp.bfloat16) + np.testing.assert_allclose( + dst_state['decoder']['layer0']['weight'][...], + jnp.array([1.0, 2.0, 3.0], dtype=jnp.bfloat16), + atol=1e-2 + ) + + # Verify scanned layer mapping cast + self.assertEqual(dst_state['decoder']['layers_0']['mlp']['weight'].dtype, jnp.bfloat16) + np.testing.assert_allclose( + dst_state['decoder']['layers_0']['mlp']['weight'][...], + jnp.array([10.0, 11.0], dtype=jnp.bfloat16), + atol=1e-2 + ) + self.assertEqual(dst_state['decoder']['layers_1']['mlp']['weight'].dtype, jnp.bfloat16) + np.testing.assert_allclose( + dst_state['decoder']['layers_1']['mlp']['weight'][...], + jnp.array([20.0, 21.0], dtype=jnp.bfloat16), + atol=1e-2 + ) + + def test_transfer_state_directly_scanned_layers_casting(self): + """Tests transfer from scanned layers container with dtype casting.""" + # Source has scanned layers in float32 + src_state = nnx.Dict( + layers=nnx.Dict( + mlp=nnx.Dict( + weight=nnx.Param(jnp.array([100.0, 200.0], dtype=jnp.float32)) + ) + ) + ) + + # Destination has unrolled layers_X in bfloat16 + dst_state = nnx.Dict( + layers=nnx.Dict( + layers_0=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.zeros((), dtype=jnp.bfloat16)))), + layers_1=nnx.Dict(mlp=nnx.Dict(weight=nnx.Param(jnp.zeros((), dtype=jnp.bfloat16)))), + ) + ) + + mock_reshard = lambda source, target: source + utils.transfer_state_directly(src_state, dst_state, reshard_fn=mock_reshard) + + # Verify casting and slicing for implicit layers + self.assertEqual(dst_state['layers']['layers_0']['mlp']['weight'].dtype, jnp.bfloat16) + np.testing.assert_allclose( + dst_state['layers']['layers_0']['mlp']['weight'][...], + jnp.array(100.0, dtype=jnp.bfloat16), + atol=1e-2 + ) + self.assertEqual(dst_state['layers']['layers_1']['mlp']['weight'].dtype, jnp.bfloat16) + np.testing.assert_allclose( + dst_state['layers']['layers_1']['mlp']['weight'][...], + jnp.array(200.0, dtype=jnp.bfloat16), + atol=1e-2 + ) + + +if __name__ == "__main__": + absltest.main() diff --git a/tests/generate/vllm_driver_test.py b/tests/generate/vllm_driver_test.py index 65cbe1e0..f7894988 100644 --- a/tests/generate/vllm_driver_test.py +++ b/tests/generate/vllm_driver_test.py @@ -59,6 +59,7 @@ def __init__(self, completion_order: Iterable[str]): self._pending: list[str] = [] self._lock = threading.Lock() self.engine_core = _StubEngineCore() + self.log_called = threading.Event() # The driver only exercises a subset of the LLMEngine surface. def add_request(self, request_id: str, *_, **__): @@ -92,6 +93,12 @@ def step(self): def abort_request(self, *_args, **_kwargs): pass + # Log stats API exercised by the driver's log thread. + def do_log_stats(self): + # Signal that the log stats method was called. + self.log_called.set() + return None + class VllmDriverAsyncTest(absltest.TestCase): @@ -139,6 +146,16 @@ def test_out_of_order_completions_preserved(self): self.assertEqual(finished_order, completion_order) self.assertNotEqual(finished_order, request_ids) + def test_log_thread_calls_do_log_stats(self): + engine = _FakeLLMEngine([]) + driver = VLLMInProcessDriver( + llm_engine=engine, log_stats_interval_s=0.01, auto_start=True + ) + self.addCleanup(driver.shutdown) + + # Wait for the log thread to call into the engine's do_log_stats. + self.assertTrue(engine.log_called.wait(timeout=1.0)) + if __name__ == "__main__": absltest.main() diff --git a/tests/generate/vllm_sampler_test.py b/tests/generate/vllm_sampler_test.py index abff6444..88200eee 100644 --- a/tests/generate/vllm_sampler_test.py +++ b/tests/generate/vllm_sampler_test.py @@ -162,8 +162,6 @@ def _run_vllm_sampler(self, server_mode, data_parallel_size: int = -1): mapping_config = mappings.MappingConfig.build(tunix_model) vllm_config = vllm_sampler.VllmConfig( - model_version=self.model_path, - max_model_len=512, mesh=self.mesh, hbm_utilization=0.2, init_with_random_weights=True, @@ -172,6 +170,11 @@ def _run_vllm_sampler(self, server_mode, data_parallel_size: int = -1): lora_config=lora_config, server_mode=server_mode, data_parallel_size=data_parallel_size, + engine_kwargs={ + "model": self.model_path, + "max_model_len": 512, + "enable_prefix_caching": True, + }, # Test kwargs forwarding ) vl_sampler = vllm_sampler.VllmSampler( @@ -234,14 +237,17 @@ def test_vllm_sampler_run_in_executor_concurrency(self): mapping_config = mappings.MappingConfig.build(tunix_model) vllm_config = vllm_sampler.VllmConfig( - model_version=self.model_path, - max_model_len=512, mesh=self.mesh, hbm_utilization=0.2, init_with_random_weights=True, tpu_backend_type="jax", mapping_config=mapping_config, server_mode=True, + engine_kwargs={ + "model": self.model_path, + "max_model_len": 512, + "enable_prefix_caching": True, + }, # Test kwargs forwarding ) vl_sampler = vllm_sampler.VllmSampler( diff --git a/tests/models/naming_test.py b/tests/models/naming_test.py index f4f27f27..27b1daa9 100644 --- a/tests/models/naming_test.py +++ b/tests/models/naming_test.py @@ -488,6 +488,41 @@ def _get_test_cases_for_model_id_exists() -> list[dict[str, str]]: ] +def _get_test_cases_for_auto_population_with_HF_model_id() -> ( + list[dict[str, str]] +): + test_cases = [] + _validate_full_model_coverage() + for model_info in _TEST_MODEL_INFOS: + test_cases.append({ + 'testcase_name': model_info.config_id, + 'model_id': model_info.id, + 'expected_name': model_info.name, + 'expected_family': model_info.family, + 'expected_version': model_info.version, + 'expected_category': model_info.category, + 'expected_config_id': model_info.config_id, + }) + return test_cases + + +def _get_test_cases_for_auto_population_with_config_id() -> ( + list[dict[str, str]] +): + test_cases = [] + _validate_full_model_coverage() + for model_info in _TEST_MODEL_INFOS: + test_cases.append({ + 'testcase_name': model_info.config_id, + 'model_id': model_info.config_id, + 'expected_family': model_info.family, + 'expected_version': model_info.version, + 'expected_category': model_info.category, + 'expected_config_id': model_info.config_id, + }) + return test_cases + + class TestNaming(parameterized.TestCase): @parameterized.named_parameters( @@ -501,9 +536,15 @@ def test_get_model_name_from_model_id( expected_name, ) - def test_get_model_name_from_model_id_invalid_fails(self): - with self.assertRaisesRegex(ValueError, 'Invalid model ID format'): - naming.get_model_name_from_model_id('Llama-3.1-8B') + def test_get_model_name_from_model_id_no_slash_succeeds(self): + self.assertEqual( + naming.get_model_name_from_model_id('Llama-3.1-8B'), 'llama-3.1-8b' + ) + + def test_get_model_name_from_model_id_config_id(self): + self.assertEqual( + naming.get_model_name_from_model_id('llama3p1_8b'), 'llama3p1_8b' + ) def test_get_model_name_from_model_id_nested_path(self): self.assertEqual( @@ -544,7 +585,15 @@ def test_get_model_family_and_version( def test_get_model_family_and_version_invalid_fails(self): with self.assertRaisesRegex( - ValueError, 'Could not determine model family for: foobar.' + ValueError, 'Could not determine model family for: foo-bar.' + ): + naming.get_model_family_and_version('foo-bar') + + def test_get_model_family_and_version_invalid_format_fails(self): + with self.assertRaisesRegex( + ValueError, + 'Invalid model ID format: .* Expected a Huggingface model ID or a' + ' ConfigId.', ): naming.get_model_family_and_version('foobar') @@ -555,6 +604,8 @@ def test_get_model_family_and_version_invalid_version_fails(self): def test_split(self): self.assertEqual(naming.split('gemma-7b'), ('gemma-', '7b')) self.assertEqual(naming.split('gemma-1.1-7b'), ('gemma-1.1-', '7b')) + self.assertEqual(naming.split('gemma_7b'), ('gemma_', '7b')) + self.assertEqual(naming.split('gemma1p1_7b'), ('gemma1p1_', '7b')) @parameterized.named_parameters(_get_test_cases_for_get_model_config_id()) def test_get_model_config_id(self, model_name: str, expected_config_id: str): @@ -570,15 +621,60 @@ def test_get_model_config_category( naming.get_model_config_category(model_name), expected_category ) - def test_model_naming_auto_population(self): - model_id = 'meta-llama/Llama-3.1-8B' - naming_info = naming.ModelNaming(model_id=model_id) - self.assertEqual(naming_info.model_id, model_id) - self.assertEqual(naming_info.model_name, 'llama-3.1-8b') - self.assertEqual(naming_info.model_family, 'llama3p1') - self.assertEqual(naming_info.model_version, '8b') - self.assertEqual(naming_info.model_config_category, 'llama3') - self.assertEqual(naming_info.model_config_id, 'llama3p1_8b') + @parameterized.named_parameters( + _get_test_cases_for_auto_population_with_HF_model_id() + ) + def test_model_naming_auto_population_with_HF_model_id( + self, + *, + model_id: str, + expected_name: str, + expected_family: str, + expected_version: str, + expected_category: str, + expected_config_id: str, + ): + with self.subTest(name='Test Model naming creation with HFModelId'): + naming_info = naming.ModelNaming(model_id=naming.HFModelId(model_id)) + self.assertEqual(naming_info.model_id, model_id) + self.assertEqual(naming_info.model_name, expected_name) + self.assertEqual(naming_info.model_family, expected_family) + self.assertEqual(naming_info.model_version, expected_version) + self.assertEqual(naming_info.model_config_category, expected_category) + self.assertEqual(naming_info.model_config_id, expected_config_id) + + with self.subTest(name='Test Model id type detection'): + self.assertTrue(naming._is_hf_model_id_type(naming_info.model_id)) + self.assertFalse(naming._is_config_id_type(naming_info.model_id)) + self.assertTrue(naming._is_hf_model_id_type(naming_info.model_name)) + self.assertFalse(naming._is_config_id_type(naming_info.model_name)) + + @parameterized.named_parameters( + _get_test_cases_for_auto_population_with_config_id() + ) + def test_model_naming_auto_population_with_config_id_model_id( + self, + *, + model_id: str, + expected_family: str, + expected_version: str, + expected_category: str, + expected_config_id: str, + ): + with self.subTest(name='Test Model naming creation with ConfigId'): + naming_info = naming.ModelNaming(model_id=naming.ConfigId(model_id)) + self.assertEqual(naming_info.model_id, model_id) + self.assertEqual(naming_info.model_name, model_id) + self.assertEqual(naming_info.model_family, expected_family) + self.assertEqual(naming_info.model_version, expected_version) + self.assertEqual(naming_info.model_config_category, expected_category) + self.assertEqual(naming_info.model_config_id, expected_config_id) + + with self.subTest(name='Test Model id type detection'): + self.assertFalse(naming._is_hf_model_id_type(naming_info.model_id)) + self.assertTrue(naming._is_config_id_type(naming_info.model_id)) + self.assertFalse(naming._is_hf_model_id_type(naming_info.model_name)) + self.assertTrue(naming._is_config_id_type(naming_info.model_name)) def test_model_naming_no_model_id(self): model_name = 'gemma-2b' @@ -608,7 +704,9 @@ def test_model_naming_mismatch(self): 'model_name set in ModelNaming and one inferred from model_id do not' ' match', ): - naming.ModelNaming(model_name='gemma-7b', model_id='google/gemma-2b') + naming.ModelNaming( + model_name='gemma-7b', model_id=naming.HFModelId('google/gemma-2b') + ) if __name__ == '__main__': diff --git a/tests/perf/perfetto_test.py b/tests/perf/perfetto_test.py index f5e47fc3..d68c65b8 100644 --- a/tests/perf/perfetto_test.py +++ b/tests/perf/perfetto_test.py @@ -59,7 +59,7 @@ def _create_mock_spans(): actor_train_groups = [g_actor] return ( - g_global_step, + [g_global_step], rollout_spans, refer_inference_spans, actor_train_groups, @@ -137,7 +137,8 @@ def add_packet_side_effect(): writer.log_trace(*_create_mock_spans()) - # Metadata (5) (Global + 4 Tracks) + Main (12) + Rollout (2) + Refer (2) + Actor (4) = 25 + # Metadata (5) (Global + Main + Rollout + Reference + Actor) + # + Merged Main (12) + Rollout (2) + Refer (2) + Actor (4) = 25 self.assertLen(captured_packets, 25) # Helper to simplify assertions @@ -170,11 +171,12 @@ def assert_slice(packet, type_, uuid, ts, name=None): with self.subTest("Metadata"): assert_global_track(captured_packets[0]) assert_metadata(captured_packets[1], "Main", 1) - assert_metadata(captured_packets[2], "Rollout", 2) - assert_metadata(captured_packets[3], "Reference", 3) - assert_metadata(captured_packets[4], "Actor", 4) + # Main -- thread 0 should NOT be created if merge succeeds + assert_metadata(captured_packets[2], "Rollout", 2000) + assert_metadata(captured_packets[3], "Reference", 2001) + assert_metadata(captured_packets[4], "Actor", 2002) - with self.subTest("Main Track"): + with self.subTest("Merged Main Track"): # global_step assert_slice(captured_packets[5], SliceBegin, 1, 0, "global_step") assert_slice(captured_packets[6], SliceEnd, 1, 10_000_000_000) @@ -201,29 +203,40 @@ def assert_slice(packet, type_, uuid, ts, name=None): assert_slice(captured_packets[16], SliceEnd, 1, 9_000_000_000) with self.subTest("Rollout Track"): - assert_slice(captured_packets[17], SliceBegin, 2, 0, "rollout") - assert_slice(captured_packets[18], SliceEnd, 2, 4_000_000_000) + assert_slice(captured_packets[17], SliceBegin, 2000, 0, "rollout") + assert_slice(captured_packets[18], SliceEnd, 2000, 4_000_000_000) with self.subTest("Reference Track"): assert_slice( - captured_packets[19], SliceBegin, 3, 4_000_000_000, "refer_inference" + captured_packets[19], + SliceBegin, + 2001, + 4_000_000_000, + "refer_inference", ) - assert_slice(captured_packets[20], SliceEnd, 3, 6_000_000_000) + assert_slice(captured_packets[20], SliceEnd, 2001, 6_000_000_000) with self.subTest("Actor Track"): # actor_training assert_slice( - captured_packets[21], SliceBegin, 4, 6_000_000_000, "actor_training" + captured_packets[21], + SliceBegin, + 2002, + 6_000_000_000, + "actor_training", ) - assert_slice(captured_packets[22], SliceEnd, 4, 9_000_000_000) + assert_slice(captured_packets[22], SliceEnd, 2002, 9_000_000_000) # peft_train_step assert_slice( - captured_packets[23], SliceBegin, 4, 6_000_000_000, "peft_train_step" + captured_packets[23], + SliceBegin, + 2002, + 6_000_000_000, + "peft_train_step", ) - assert_slice(captured_packets[24], SliceEnd, 4, 9_000_000_000) + assert_slice(captured_packets[24], SliceEnd, 2002, 9_000_000_000) mock_builder.serialize.assert_called_once() - mock_open.return_value.write.assert_called_once() if __name__ == "__main__": diff --git a/tests/perf/span_test.py b/tests/perf/span_test.py new file mode 100644 index 00000000..c42c365b --- /dev/null +++ b/tests/perf/span_test.py @@ -0,0 +1,233 @@ +# Copyright 2026 Google LLC +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from typing import List, Optional +from absl.testing import absltest +from tunix.perf import span + + +def create_span(name: str, begin: float, end: float) -> span.Span: + s = span.Span(name, begin) + s.end = end + return s + + +def create_group( + name: str, + begin: float, + end: float, + children: Optional[List[span.Span]] = None, +) -> span.SpanGroup: + g = span.SpanGroup(name, None) + g.begin = begin + g.end = end + if children: + for child in children: + g.inner.append(child) + if isinstance(child, span.SpanGroup): + child.outer = g + return g + + +class SpanTest(absltest.TestCase): + + def test_clone_span(self): + s = create_span("s1", 1.0, 2.0) + clone = span.clone_span_or_group(s) + self.assertIsNot(s, clone) + self.assertEqual(s.name, clone.name) + self.assertEqual(s.begin, clone.begin) + self.assertEqual(s.end, clone.end) + self.assertIsInstance(clone, span.Span) + + def test_clone_span_group(self): + s1 = create_span("s1", 1.0, 2.0) + g1 = create_group("g1", 0.0, 3.0, [s1]) + + clone = span.clone_span_or_group(g1) + + with self.subTest("CloneGroupProperties"): + self.assertIsNot(g1, clone) + self.assertEqual(g1.name, clone.name) + self.assertEqual(g1.begin, clone.begin) + self.assertEqual(g1.end, clone.end) + self.assertIsInstance(clone, span.SpanGroup) + self.assertLen(clone.inner, 1) + + with self.subTest("CloneInnerSpan"): + cloned_s1 = clone.inner[0] + self.assertIsNot(s1, cloned_s1) + self.assertEqual(s1.name, cloned_s1.name) + self.assertEqual(s1.begin, cloned_s1.begin) + self.assertEqual(s1.end, cloned_s1.end) + self.assertIsInstance(cloned_s1, span.Span) + + def test_clone_span_group_parent_pointers(self): + # Check that outer/parent pointers are correctly set after cloning. + g2 = create_group("g2", 1.5, 2.5) + g_parent = create_group("parent", 0.0, 10.0, [g2]) + clone_parent = span.clone_span_or_group(g_parent) + self.assertLen(clone_parent.inner, 1) + clone_g2 = clone_parent.inner[0] + self.assertIsInstance(clone_g2, span.SpanGroup) + self.assertIs(clone_g2.outer, clone_parent) + + def test_merge_identical_spans(self): + s1 = create_span("s1", 1.0, 2.0) + s2 = create_span("s1", 1.0, 2.0) + + merged = span.merge_span_group_trees(s1, s2) + self.assertEqual(merged.name, "s1") + self.assertEqual(merged.begin, 1.0) + self.assertEqual(merged.end, 2.0) + self.assertIsNot(merged, s1) + self.assertIsNot(merged, s2) + + def test_merge_identical_span_groups(self): + s1 = create_span("s1", 1.0, 2.0) + g1 = create_group("g1", 0.0, 3.0, [s1]) + + s2 = create_span("s1", 1.0, 2.0) + g2 = create_group("g1", 0.0, 3.0, [s2]) + + merged = span.merge_span_group_trees(g1, g2) + + self.assertEqual(merged.name, "g1") + self.assertLen(merged.inner, 1) + self.assertEqual(merged.inner[0].name, "s1") + + def test_merge_disjoint_children(self): + s1 = create_span("s1", 1.0, 2.0) + g1 = create_group("root", 0.0, 10.0, [s1]) + + s2 = create_span("s2", 3.0, 4.0) + g2 = create_group("root", 0.0, 10.0, [s2]) + + merged = span.merge_span_group_trees(g1, g2) + + self.assertEqual(merged.name, "root") + self.assertLen(merged.inner, 2) + self.assertEqual(merged.inner[0].name, "s1") + self.assertEqual(merged.inner[1].name, "s2") + + def test_merge_overlap_identical_children(self): + # Tree 1: Root -> [A (1-2), B (3-4)] + # Tree 2: Root -> [B (3-4), C (5-6)] + # Result: Root -> [A, B, C] + sA = create_span("A", 1.0, 2.0) + sB1 = create_span("B", 3.0, 4.0) + g1 = create_group("root", 0.0, 10.0, [sA, sB1]) + + sB2 = create_span("B", 3.0, 4.0) + sC = create_span("C", 5.0, 6.0) + g2 = create_group("root", 0.0, 10.0, [sB2, sC]) + + merged = span.merge_span_group_trees(g1, g2) + + self.assertLen(merged.inner, 3) + self.assertEqual(merged.inner[0].name, "A") + self.assertEqual(merged.inner[1].name, "B") + self.assertEqual(merged.inner[2].name, "C") + + def test_merge_nested_recursion(self): + # Tree 1: Root -> GroupA (1-5) -> [Span1 (2-3)] + # Tree 2: Root -> GroupA (1-5) -> [Span2 (3-4)] + # Result: Root -> GroupA (1-5) -> [Span1, Span2] + span1 = create_span("s1", 2.0, 3.0) + ga1 = create_group("GroupA", 1.0, 5.0, [span1]) + root1 = create_group("Root", 0.0, 10.0, [ga1]) + + span2 = create_span("s2", 3.0, 4.0) + ga2 = create_group("GroupA", 1.0, 5.0, [span2]) + root2 = create_group("Root", 0.0, 10.0, [ga2]) + + merged = span.merge_span_group_trees(root1, root2) + + self.assertLen(merged.inner, 1) + merged_ga = merged.inner[0] + self.assertEqual(merged_ga.name, "GroupA") + self.assertLen(merged_ga.inner, 2) + self.assertEqual(merged_ga.inner[0].name, "s1") + self.assertEqual(merged_ga.inner[1].name, "s2") + + def test_merge_conflict_overlap_spans(self): + # Overlapping spans with different names or times + s1 = create_span("s1", 1.0, 3.0) + g1 = create_group("root", 0.0, 10.0, [s1]) + + s2 = create_span("s2", 2.0, 4.0) # Overlaps s1 + g2 = create_group("root", 0.0, 10.0, [s2]) + + with self.assertRaisesRegex(ValueError, "Overlap detected"): + span.merge_span_group_trees(g1, g2) + + def test_merge_conflict_same_name_diff_time(self): + # Same name but different time -> treated as different, but if overlap -> error + s1 = create_span("s1", 1.0, 3.0) + g1 = create_group("root", 0.0, 10.0, [s1]) + + s2 = create_span("s1", 2.0, 4.0) # Overlaps s1, different time + g2 = create_group("root", 0.0, 10.0, [s2]) + + with self.assertRaisesRegex(ValueError, "Overlap detected"): + span.merge_span_group_trees(g1, g2) + + def test_merge_root_mismatch(self): + g1 = create_group("root1", 0.0, 10.0) + g2 = create_group("root2", 0.0, 10.0) + + with self.assertRaisesRegex(ValueError, "Roots are not identical"): + span.merge_span_group_trees(g1, g2) + + def test_merge_type_mismatch(self): + # Span vs SpanGroup with same name and time + s1 = create_span("node", 1.0, 2.0) + g1 = create_group("node", 1.0, 2.0) + + with self.assertRaisesRegex(ValueError, "Roots are not identical"): + span.merge_span_group_trees(s1, g1) + + def test_merge_empty_groups(self): + g1 = create_group("root", 0.0, 10.0) + g2 = create_group("root", 0.0, 10.0) + merged = span.merge_span_group_trees(g1, g2) + self.assertEmpty(merged.inner) + + def test_merge_multiple_overlaps(self): + # [A(1-2), B(3-4), C(5-6)] merged with [A(1-2), C(5-6)] + # Should result in [A, B, C] + + sA = create_span("A", 1.0, 2.0) + sB = create_span("B", 3.0, 4.0) + sC = create_span("C", 5.0, 6.0) + + g1 = create_group("root", 0.0, 10.0, [sA, sB, sC]) + g2 = create_group("root", 0.0, 10.0, [sA, sC]) + + merged = span.merge_span_group_trees(g1, g2) + self.assertLen(merged.inner, 3) + + def test_merge_identical_spans_with_jitter(self): + s1 = create_span("s1", 1.0, 2.0) + s2 = create_span("s1", 1.0 + 1e-10, 2.0 - 1e-10) + + self.assertTrue(span._are_nodes_shallowly_identical(s1, s2)) + merged = span.merge_span_group_trees(s1, s2) + self.assertEqual(merged.name, "s1") + self.assertEqual(merged.begin, 1.0) + self.assertEqual(merged.end, 2.0) + + +if __name__ == "__main__": + absltest.main() diff --git a/tests/rl/agentic/pipeline/rollout_orchestrator_test.py b/tests/rl/agentic/pipeline/rollout_orchestrator_test.py index 39afdb3c..4d0d4e49 100644 --- a/tests/rl/agentic/pipeline/rollout_orchestrator_test.py +++ b/tests/rl/agentic/pipeline/rollout_orchestrator_test.py @@ -2,10 +2,12 @@ import asyncio from collections.abc import Mapping +import math from typing import Any from unittest import mock from absl.testing import absltest +from absl.testing import parameterized from tunix.rl.agentic import utils from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.agents import base_agent @@ -27,8 +29,10 @@ def update_from_model(self, response: str, **kwargs) -> agent_types.Action: class MockEnv(base_environment.BaseTaskEnv): """A mock environment.""" - def __init__(self, task: Mapping[str, Any] | None = None, env_id: int = 0): - super().__init__(task=task) + def __init__( + self, task: Mapping[str, Any] | None = None, env_id: int = 0, **kwargs + ): + super().__init__(task=task, **kwargs) self.env_id = env_id def _initial_observation(self): @@ -43,13 +47,7 @@ def _step_impl(self, action): ) -def _group_by_pair_index( - pair_index: int, env: MockEnv, traj: rollout_orchestrator.Trajectory -) -> int: - return pair_index - - -class RolloutOrchestratorTest(absltest.TestCase): +class RolloutOrchestratorTest(parameterized.TestCase): def setUp(self): super().setUp() @@ -61,22 +59,54 @@ def setUp(self): self.mock_collect = self.collect_patcher.start() self.addCleanup(self.collect_patcher.stop) - def test_streaming_successful_run(self): - asyncio.run(self._test_streaming_successful_run()) + @parameterized.named_parameters( + dict( + testcase_name='group_size_1_batch_size_2', + num_pairs=3, + group_size=1, + batch_size=2, + ), + dict( + testcase_name='group_size_2_batch_size_2', + num_pairs=4, + group_size=2, + batch_size=2, + ), + dict( + testcase_name='group_size_1_batch_size_5', + num_pairs=5, + group_size=1, + batch_size=5, + ), + dict( + testcase_name='group_size_3_batch_size_3', + num_pairs=6, + group_size=3, + batch_size=3, + ), + dict( + testcase_name='group_size_2_batch_size_4', + num_pairs=6, + group_size=2, + batch_size=4, + ), + ) + def test_streaming_successful_run(self, num_pairs, group_size, batch_size): + asyncio.run( + self._test_streaming_successful_run(num_pairs, group_size, batch_size) + ) - async def _test_streaming_successful_run(self): + async def _test_streaming_successful_run( + self, num_pairs, group_size, batch_size + ): orchestrator = rollout_orchestrator.RolloutOrchestrator( max_concurrency=2, rollout_sync_lock=utils.RolloutSyncLock(), ) - num_pairs = 3 - num_episodes = 2 - group_size = 2 - batch_size = 2 def pair_generator(): for i in range(num_pairs): - yield MockAgent(), MockEnv(env_id=i) + yield MockAgent(), MockEnv(env_id=i, group_id=0, pair_index=i) async def side_effect_fn(*args, **kwargs): env = args[1] @@ -88,8 +118,7 @@ async def side_effect_fn(*args, **kwargs): orchestrator.run_producers_from_stream( pairs_stream=pair_generator(), group_size=group_size, - group_key=_group_by_pair_index, - num_episodes=num_episodes, + group_key_fn=lambda i, env, traj: i // group_size, ) ) await asyncio.sleep(0) @@ -99,33 +128,48 @@ async def side_effect_fn(*args, **kwargs): batches.append(batch) await producer_task - self.assertLen(batches, 3) + # Check if the orchestrator yields the correct number of batches. + self.assertLen(batches, math.ceil(num_pairs / batch_size)) + for batch in batches: + self.assertLessEqual(len(batch), batch_size) + if group_size > 1 and batch_size <= group_size: + # If group_size > 1 and batch_size <= group_size, items in a batch + # are expected to come from the same group. + group_ids = set(item.group_id for item in batch) + self.assertLen(group_ids, 1) + all_items = [] for batch in batches: - self.assertLen(batch, 2) all_items.extend(batch) - self.assertLen(all_items, 6) + self.assertLen(all_items, num_pairs) pair_indices = sorted([item.pair_index for item in all_items]) - self.assertEqual(pair_indices, [0, 0, 1, 1, 2, 2]) + self.assertEqual(pair_indices, list(range(num_pairs))) - episode_ids_per_pair = {} + items_by_group = {} for item in all_items: self.assertEqual( item.traj, {'trajectory': [f'traj_for_env_{item.pair_index}']} ) - self.assertEqual(item.group_id, item.pair_index) - self.assertEqual(item.episode_id, 0) - self.assertIn(item.metadata['generation_id'], [0, 1]) - if item.pair_index not in episode_ids_per_pair: - episode_ids_per_pair[item.pair_index] = [] - episode_ids_per_pair[item.pair_index].append( - item.metadata['generation_id'] + self.assertEqual(item.group_id, item.pair_index // group_size) + if item.group_id not in items_by_group: + items_by_group[item.group_id] = [] + items_by_group[item.group_id].append(item) + + self.assertLen(items_by_group, num_pairs // group_size) + for group_id in items_by_group: + self.assertLen(items_by_group[group_id], group_size) + pair_indices_in_group = sorted( + [item.pair_index for item in items_by_group[group_id]] ) - - for i in range(num_pairs): - self.assertCountEqual(episode_ids_per_pair[i], [0, 1]) + expected_pair_indices = list( + range( + group_id * group_size, + group_id * group_size + group_size, + ) + ) + self.assertEqual(pair_indices_in_group, expected_pair_indices) def test_streaming_producer_runner_exception(self): asyncio.run(self._test_streaming_producer_runner_exception()) @@ -140,21 +184,21 @@ async def _test_streaming_producer_runner_exception(self): def pair_generator(): for i in range(num_pairs): - yield MockAgent(), MockEnv(env_id=i) + yield MockAgent(), MockEnv(env_id=i, group_id=0, pair_index=i) async def failing_side_effect(*args, **kwargs): env = args[1] if env.env_id == failing_pair_index: raise ValueError('Collection failed!') return {'trajectory': [f'traj_for_env_{env.env_id}']} + self.mock_collect.side_effect = failing_side_effect producer_task = asyncio.create_task( orchestrator.run_producers_from_stream( pairs_stream=pair_generator(), group_size=1, - group_key=_group_by_pair_index, - num_episodes=1, + group_key_fn=lambda i, *_: i, ) ) await asyncio.sleep(0) @@ -179,7 +223,7 @@ def faulty_generator(): for i in range(5): if i == failing_pair_index: raise ValueError('Generator failed!') - yield MockAgent(), MockEnv(env_id=i) + yield MockAgent(), MockEnv(env_id=i, group_id=0, pair_index=i) self.mock_collect.side_effect = None self.mock_collect.return_value = {'trajectory': ['mock_traj']} @@ -188,8 +232,7 @@ def faulty_generator(): orchestrator.run_producers_from_stream( pairs_stream=faulty_generator(), group_size=1, - group_key=_group_by_pair_index, - num_episodes=1, + group_key_fn=lambda i, *_: i, ) ) await asyncio.sleep(0) diff --git a/tests/rl/agentic/queue_manager/group_queue_manager_test.py b/tests/rl/agentic/queue_manager/group_queue_manager_test.py index 160253b3..7cfc8aa8 100644 --- a/tests/rl/agentic/queue_manager/group_queue_manager_test.py +++ b/tests/rl/agentic/queue_manager/group_queue_manager_test.py @@ -22,13 +22,12 @@ def _create_item( - group_id: str, episode_id: int, pair_index: int = 0 + group_id: str, pair_index: int = 0 ) -> agent_types.TrajectoryItem: """Helper to create a TrajectoryItem for testing.""" return agent_types.TrajectoryItem( pair_index=pair_index, group_id=group_id, - episode_id=episode_id, start_step=0, traj=None, ) @@ -41,15 +40,13 @@ def test_put_and_get_simple_batch(self): async def _run_test(): manager = group_queue_manager.GroupQueueManager(group_size=2) - item1 = _create_item("g1", 1) + item1 = _create_item("g1", 0) item2 = _create_item("g1", 1) await manager.put(item1) - self.assertEqual(manager._open_bucket_count(), 1) self.assertEmpty(manager._ready_groups) await manager.put(item2) - self.assertEqual(manager._open_bucket_count(), 0) self.assertLen(manager._ready_groups, 1) batch = await manager.get_batch(2) @@ -63,7 +60,7 @@ def test_get_batch_waits_for_items(self): async def _run_test(): manager = group_queue_manager.GroupQueueManager(group_size=2) - item1 = _create_item("g1", 1) + item1 = _create_item("g1", 0) item2 = _create_item("g1", 1) async def producer(): @@ -85,7 +82,7 @@ def test_batching_with_leftovers(self): async def _run_test(): manager = group_queue_manager.GroupQueueManager(group_size=3) - items = [_create_item("g1", 1, i) for i in range(3)] + items = [_create_item("g1", i) for i in range(3)] for item in items: await manager.put(item) @@ -103,32 +100,6 @@ async def _run_test(): asyncio.run(_run_test()) - def test_max_open_buckets(self): - """Tests that put blocks when max_open_buckets is reached.""" - - async def _run_test(): - manager = group_queue_manager.GroupQueueManager( - group_size=2, max_open_buckets=1 - ) - item_g1 = _create_item("g1", 1) - item_g2 = _create_item("g2", 1) - - await manager.put(item_g1) - - put_task = asyncio.create_task(manager.put(item_g2)) - - await asyncio.sleep(0.01) - self.assertFalse(put_task.done()) - - await manager.put(_create_item("g1", 1)) - await asyncio.sleep(0.01) - - await put_task - self.assertEqual(manager._open_bucket_count(), 1) - self.assertIn(("g2", 1), manager._buckets) - - asyncio.run(_run_test()) - def test_put_exception(self): """Tests that an exception is propagated to put and get calls.""" @@ -138,7 +109,7 @@ async def _run_test(): await manager.put_exception(exc) with self.assertRaises(ValueError): - await manager.put(_create_item("g1", 1)) + await manager.put(_create_item("g1", 0)) with self.assertRaises(ValueError): await manager.get_batch(1) diff --git a/tests/rl/agentic/trajectory/trajectory_collect_engine_test.py b/tests/rl/agentic/trajectory/trajectory_collect_engine_test.py index 156633ed..b6b69ed4 100644 --- a/tests/rl/agentic/trajectory/trajectory_collect_engine_test.py +++ b/tests/rl/agentic/trajectory/trajectory_collect_engine_test.py @@ -102,7 +102,6 @@ def test_collect_trajectory_mode(self): env=self.mock_env, model_call=self.mock_model_call, final_reward_fn=self.mock_final_reward_fn, - max_steps=5, gamma=0.9, ) result_traj = asyncio.run(self._run_collect(engine, mode='Trajectory')) @@ -134,7 +133,6 @@ def test_collect_conversation_mode(self): agent=self.mock_agent, env=self.mock_env, model_call=self.mock_model_call, - max_steps=5, ) conversation = asyncio.run(self._run_collect(engine, mode='Conversation')) @@ -162,7 +160,6 @@ def test_collect_with_tokenization(self, mock_convert): model_call=self.mock_model_call, tokenizer=self.mock_tokenizer, chat_parser=self.mock_chat_parser, - max_steps=5, ) token_data = asyncio.run(self._run_collect(engine, mode='Token')) expected_tokens = { @@ -264,7 +261,6 @@ def test_collect_timeout(self): agent=self.mock_agent, env=self.mock_env, model_call=self.mock_model_call, - max_steps=5, timeout=0.1, ) result_traj = asyncio.run(self._run_collect(engine, mode='Trajectory')) @@ -345,7 +341,6 @@ def _reset_agent(): mock_model_call = mock.Mock(side_effect=['resp1', 'resp2a', 'resp2b']) engine_args = { 'model_call': mock_model_call, - 'max_steps': 5, 'mode': 'Conversation', } diff --git a/tests/rl/experimental/agentic_grpo_learner_test.py b/tests/rl/experimental/agentic_grpo_learner_test.py index 376076a9..eb922a28 100644 --- a/tests/rl/experimental/agentic_grpo_learner_test.py +++ b/tests/rl/experimental/agentic_grpo_learner_test.py @@ -41,14 +41,16 @@ from tunix.generate import tokenizer_adapter from tunix.rl import function_registry from tunix.rl import rl_cluster as rl_cluster_lib +from tunix.rl.agentic.agents.agent_types import Action, Step +from tunix.rl.agentic.agents.base_agent import ConversationAgentBase +from tunix.rl.agentic.environments.base_environment import BaseTaskEnv, EnvStepResult from tunix.rl.experimental import agentic_grpo_learner from tunix.rl.queue import data_queue as queue_lib from tunix.rl.rollout import base_rollout +from tunix.sft import metrics_logger from tunix.tests import test_common +from tunix.utils import trajectory_logger from typing_extensions import override -from tunix.rl.agentic.agents.base_agent import ConversationAgentBase -from tunix.rl.agentic.agents.agent_types import Action, Step -from tunix.rl.agentic.environments.base_environment import BaseTaskEnv, EnvStepResult os.environ["XLA_FLAGS"] = "--xla_force_host_platform_device_count=2" Mesh = sharding.Mesh @@ -135,9 +137,7 @@ def assistant_token(self): class _LearnerWithException(agentic_grpo_learner.GRPOLearner): - def _batch_to_train_example( - self, batch_results, cached_inputs_for_window, mode - ): + def _batch_to_train_example(self, batch_results, mode): raise ValueError("test exception in producer") @@ -159,7 +159,6 @@ class _MockTrainer(agentic_grpo_learner.GRPOLearner): def __init__(self, algo_config): self.algo_config = algo_config self.rl_cluster = mock.Mock() - self.rl_cluster.buffer_metrics = mock.Mock() self.metric_fns = [] def _create_micro_batch_iterator(self, iterator, batch_size): @@ -170,30 +169,17 @@ def _create_micro_batch_iterator(self, iterator, batch_size): yield jax.tree.map(lambda x, index=i: x[index : index + 1], batch) @override - def _batch_to_train_example( - self, batch_results, cached_inputs_for_window, mode - ): - del batch_results, mode + def _batch_to_train_example(self, batch_results, mode): + del mode examples = [] for _ in range(self.algo_config.num_generations): examples.append( types.SimpleNamespace( - prompt_ids=np.array( - [cached_inputs_for_window[0]["prompts"][0]] - ), + prompt_ids=batch_results[1][0]["prompts"], ) ) return examples - @override - def _compute_trajectory_ids( - self, example: TrainingInputT, prompt_index: int - ) -> list[str]: - return [ - f"{prompt_index}_{i}" - for i in range(self.algo_config.num_generations) - ] - @override async def _orchestrator_producer( self, @@ -227,7 +213,8 @@ async def _orchestrator_producer( i += 1 algo_config = agentic_grpo_learner.GRPOConfig( - num_generations=2, num_iterations=2 + num_generations=2, + num_iterations=2, ) trainer = _MockTrainer(algo_config) @@ -290,7 +277,6 @@ def test_num_iterations_greater_than_1(self): train_micro_batch_size=1, # to control calls to update_actor ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=256, kv_cache_size=1024, ), @@ -306,6 +292,7 @@ def test_num_iterations_greater_than_1(self): num_generations=2, num_iterations=2, # > 1 loss_algo="grpo", + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -439,7 +426,6 @@ def create_learner( checkpoint_root_directory=ckpt_dir, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=32, kv_cache_size=256, temperature=0.5, @@ -455,6 +441,7 @@ def create_learner( grpo_config = agentic_grpo_learner.GRPOConfig( num_generations=2, num_iterations=1, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -502,9 +489,8 @@ def test_micro_batch_training( mini_batch_size, train_micro_batch_size, ): - def reward_fn_for_tracking(trajectories, prompts, **kwargs): - for t_id, prompt in zip(kwargs["trajectory_ids"], prompts): - trajectories[kwargs["mode"]][t_id] = prompt + def reward_fn(prompts, **kwargs): + del kwargs return [1.0] * len(prompts) def create_learner( @@ -540,7 +526,6 @@ def create_learner( train_micro_batch_size=train_micro_batch_size, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=32, kv_cache_size=256, temperature=0.5, @@ -556,12 +541,11 @@ def create_learner( grpo_config = agentic_grpo_learner.GRPOConfig( num_generations=2, num_iterations=1, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, - reward_fns=lambda **kwargs: reward_fn_for_tracking( - trajectories=trajectories, **kwargs - ), + reward_fns=reward_fn, algo_config=grpo_config, chat_parser=MockChatParser(), ) @@ -598,92 +582,6 @@ def create_learner( ) self.assertEqual(grpo_learner_base.rl_cluster.global_steps, 1) - def test_trajectory_ids(self): - def reward_fn_for_tracking(trajectories, prompts, **kwargs): - for t_id, prompt in zip(kwargs["trajectory_ids"], prompts): - trajectories[kwargs["mode"]][t_id] = prompt - return [1.0] * len(prompts) - - def create_learner( - mini_batch_size, - train_micro_batch_size, - trajectories, - ): - vocab = test_common.MockVocab() - tokenizer = tokenizer_adapter.TokenizerAdapter(vocab) - model = test_common.ToyTransformer( - config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), - rngs=nnx.Rngs(0), - ) - ref_model = test_common.ToyTransformer( - config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), - rngs=nnx.Rngs(0), - ) - - mesh = pxla.thread_resources.env.physical_mesh - cluster_config = rl_cluster_lib.ClusterConfig( - role_to_mesh={ - rl_cluster_lib.Role.ACTOR: mesh, - rl_cluster_lib.Role.REFERENCE: mesh, - rl_cluster_lib.Role.ROLLOUT: mesh, - }, - rollout_engine="vanilla", - offload_to_cpu=False, - training_config=rl_cluster_lib.RLTrainingConfig( - actor_optimizer=optax.sgd(1e-3), - eval_every_n_steps=10, - max_steps=20, - mini_batch_size=mini_batch_size, - train_micro_batch_size=train_micro_batch_size, - ), - rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, - max_prompt_length=32, - kv_cache_size=256, - temperature=0.5, - ), - ) - rl_cluster = rl_cluster_lib.RLCluster( - actor=model, - reference=ref_model, - tokenizer=tokenizer, - cluster_config=cluster_config, - ) - - grpo_config = agentic_grpo_learner.GRPOConfig( - num_generations=2, - num_iterations=1, - ) - grpo_learner = agentic_grpo_learner.GRPOLearner( - rl_cluster=rl_cluster, - reward_fns=lambda **kwargs: reward_fn_for_tracking( - trajectories=trajectories, **kwargs - ), - algo_config=grpo_config, - chat_parser=MockChatParser(), - ) - return grpo_learner, model - - train_ds = [{ - "prompts": [str(i) for i in range(8)], - "answer": [str(i) for i in range(8)], - "question": [str(i) for i in range(8)], - }] - - # Config 1: mini_batch_size=4, train_micro_batch_size=4 - trajectories1 = {"train": {}, "eval": {}} - learner1, model1 = create_learner(4, 4, trajectories1) - learner1.train(train_ds) - - # Config 2: mini_batch_size=8, train_micro_batch_size=2 - trajectories2 = {"train": {}, "eval": {}} - learner2, model2 = create_learner(8, 2, trajectories2) - learner2.train(train_ds) - - params1 = nnx.state(model1, nnx.Param) - params2 = nnx.state(model2, nnx.Param) - jax.tree.map_with_path(test_common.assert_close, params1, params2) - def test_resume_training(self): ckpt_dir = tempfile.mkdtemp() self.addCleanup(shutil.rmtree, ckpt_dir) @@ -733,7 +631,6 @@ def create_learner( offload_to_cpu=False, training_config=training_config, rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=32, kv_cache_size=256, temperature=0.5, @@ -749,6 +646,7 @@ def create_learner( grpo_config = agentic_grpo_learner.GRPOConfig( num_generations=2, num_iterations=1, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -812,7 +710,6 @@ def test_exception_handling(self): eval_every_n_steps=10, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=32, kv_cache_size=256, ), @@ -823,7 +720,7 @@ def test_exception_handling(self): tokenizer=tokenizer, cluster_config=cluster_config, ) - grpo_config = agentic_grpo_learner.GRPOConfig() + grpo_config = agentic_grpo_learner.GRPOConfig(max_response_length=10) learner = _LearnerWithException( rl_cluster=rl_cluster, reward_fns=reward_fn_1, @@ -883,7 +780,6 @@ def test_grpo_learner(self, reward_fns, loss_algo): gradient_accumulation_steps=None, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=256, kv_cache_size=1024, ), @@ -900,6 +796,7 @@ def test_grpo_learner(self, reward_fns, loss_algo): num_generations=2, num_iterations=1, loss_algo=loss_algo, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -1017,7 +914,6 @@ def test_on_off_policy_training(self, offpolicy_steps): gradient_accumulation_steps=None, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=256, kv_cache_size=1024, ), @@ -1034,6 +930,7 @@ def test_on_off_policy_training(self, offpolicy_steps): num_iterations=1, loss_algo="grpo", off_policy_steps=offpolicy_steps, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -1111,7 +1008,84 @@ def test_put_prompts_to_queue(self): grpo_learner._put_prompts_to_queue(prompt_queue, batch2) self.assertIsNone(prompt_queue.get_nowait()) - @unittest.skip("b/461854722") + def test_trajectory_logging(self): + log_dir = tempfile.mkdtemp() + self.addCleanup(shutil.rmtree, log_dir) + vocab = test_common.MockVocab() + tokenizer = tokenizer_adapter.TokenizerAdapter(vocab) + model = test_common.ToyTransformer( + config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), + rngs=nnx.Rngs(0), + ) + ref_model = test_common.ToyTransformer( + config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), + rngs=nnx.Rngs(0), + ) + + mesh = pxla.thread_resources.env.physical_mesh + cluster_config = rl_cluster_lib.ClusterConfig( + role_to_mesh={ + rl_cluster_lib.Role.ACTOR: mesh, + rl_cluster_lib.Role.REFERENCE: mesh, + rl_cluster_lib.Role.ROLLOUT: mesh, + }, + rollout_engine="vanilla", + offload_to_cpu=False, + training_config=rl_cluster_lib.RLTrainingConfig( + actor_optimizer=optax.sgd(1e-3), + eval_every_n_steps=2, + max_steps=1, + gradient_accumulation_steps=None, + metrics_logging_options=metrics_logger.MetricsLoggerOptions( + log_dir=log_dir + ), + ), + rollout_config=base_rollout.RolloutConfig( + max_prompt_length=256, + kv_cache_size=1024, + ), + ) + rl_cluster = rl_cluster_lib.RLCluster( + actor=model, + reference=ref_model, + tokenizer=tokenizer, + cluster_config=cluster_config, + ) + + grpo_config = agentic_grpo_learner.GRPOConfig( + num_generations=2, + num_iterations=1, + loss_algo="grpo", + max_response_length=10, + ) + grpo_learner = agentic_grpo_learner.GRPOLearner( + rl_cluster=rl_cluster, + reward_fns=reward_fn_1, + algo_config=grpo_config, + metric_fns=[lambda **kwargs: {"test_metric": (1.0, np.mean)}], + chat_parser=MockChatParser(), + ) + train_ds = _dummy_dataset(MySource(data=["1"], repeat=1), batch_size=1) + + with ( + mock.patch.object(trajectory_logger, "log_item") as mock_log_item, + mock.patch.object(rl_cluster, "generate", side_effect=_mock_generate), + ): + grpo_learner.train(train_ds) + if grpo_learner._trajectory_logger: + grpo_learner._trajectory_logger.stop() + self.assertEqual(grpo_learner.rl_cluster.global_steps, 1) + self.assertEqual(mock_log_item.call_count, grpo_config.num_generations) + + for i in range(grpo_config.num_generations): + traj = mock_log_item.call_args_list[i][0][1] + self.assertIn("conversation_text", traj) + conversation = traj["conversation_text"] + assistant_msgs = [m for m in conversation if m["role"] == "assistant"] + self.assertNotEmpty(assistant_msgs) + self.assertIn(assistant_msgs[0]["content"], _MOCK_RESPONSES) + self.assertEqual(traj.get("policy_version"), 0) + def test_grpo_with_lora_model(self): # reshard through default device_put. split_index = self.device_count // 2 @@ -1157,7 +1131,6 @@ def test_grpo_with_lora_model(self): max_steps=10, ), rollout_config=base_rollout.RolloutConfig( - max_tokens_to_generate=10, max_prompt_length=256, kv_cache_size=1024, ), @@ -1171,6 +1144,7 @@ def test_grpo_with_lora_model(self): grpo_config = agentic_grpo_learner.GRPOConfig( num_generations=2, num_iterations=1, + max_response_length=10, ) grpo_learner = agentic_grpo_learner.GRPOLearner( @@ -1202,7 +1176,6 @@ def test_grpo_with_lora_model(self): ) def test_customized_agent_env(self): - class MockEnv(BaseTaskEnv): def __init__(self, entry: dict[str, str], max_steps: int, **kwargs): @@ -1213,7 +1186,7 @@ def _initial_observation(self) -> Any: return "Initial prompt." def _step_impl(self, action: Any) -> EnvStepResult: - if self.step_count < self.max_steps - 1: + if self.step_count <= self.max_steps: reward = 1.0 done = False else: @@ -1237,28 +1210,66 @@ def _observation_to_messages(self, observation, reward, done, info): if max_steps is not None: remaining_steps = max_steps - self.step - 1 if remaining_steps > 0: - observation += f"\nSteps Remaining: {remaining_steps}" + observation += f" Steps Remaining: {remaining_steps}" else: - observation += "\nYou have reached the maximum number of steps." + observation += " You have reached the maximum number of steps." self._messages.append({"role": "user", "content": observation}) - self.cur_step = Step(observation=observation) + step = self.get_current_state() + if step: + step.observation = observation def update_from_model(self, response, **kwargs): - self._trajectory.steps.append(self.cur_step) - cur_step = self._trajectory.steps[-1] - cur_step.model_response = response - cur_step.action = f"Model action: {response}" + step = Step(model_response=response, action=f"Model action: {response}") + self._trajectory.steps.append(step) self._messages.append({"role": "assistant", "content": response}) - return Action(action=cur_step.action) + self.step += 1 + return Action(action=step.action) + + unique_words = {word for line in _MOCK_RESPONSES for word in line.split()} + words = [ + "", + "", + "", + "System:", + "User:", + "Assistant:", + "Initial", + "prompt.", + "System", + "Observation", + "after", + "step", + "Steps", + "Remaining:", + "You", + "have", + "reached", + "the", + "maximum", + "number", + "of", + "steps.", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "10", + ] + words.extend(sorted(unique_words)) + mapping_text_to_id = {word: i for i, word in enumerate(words)} - vocab = test_common.MockVocab() + vocab = test_common.MockVocab(mapping_text_to_id=mapping_text_to_id) tokenizer = tokenizer_adapter.TokenizerAdapter(vocab) model = test_common.ToyTransformer( config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), rngs=nnx.Rngs(0), ) - original_variables = jax.tree.map(jnp.copy, nnx.state(model, nnx.Param)) ref_model = test_common.ToyTransformer( config=test_common.ModelConfig(vocab_size=vocab.GetPieceSize()), rngs=nnx.Rngs(0), @@ -1281,7 +1292,7 @@ def update_from_model(self, response, **kwargs): ), rollout_config=base_rollout.RolloutConfig( max_tokens_to_generate=10, - max_prompt_length=256, + max_prompt_length=32, kv_cache_size=1024, ), ) @@ -1297,6 +1308,8 @@ def update_from_model(self, response, **kwargs): num_generations=2, num_iterations=1, loss_algo="grpo", + max_response_length=64, + max_concurrency=1, # so the output is deterministic. ) grpo_learner = agentic_grpo_learner.GRPOLearner( rl_cluster=rl_cluster, @@ -1310,18 +1323,30 @@ def update_from_model(self, response, **kwargs): env_kwargs={"max_steps": 3}, ) - agents = [] - envs = [] + agents, envs = [], [] original_fn = grpo_learner._create_agent_env_pair - def _patch_create_agent_env_pair(single_example, group_id): - agent, env = original_fn(single_example, group_id) + def _patch_create_agent_env_pair(single_example, group_id, pair_index): + agent, env = original_fn(single_example, group_id, pair_index) agents.append(agent) envs.append(env) return agent, env + original_process_results = grpo_learner._process_results + processed_results = [] + + def _patch_process_results( + trajectories, + mode, + expected_step, + ): + res = original_process_results(trajectories, mode, expected_step) + processed_results.append(res) + return res + grpo_learner._create_agent_env_pair = _patch_create_agent_env_pair + grpo_learner._process_results = _patch_process_results self.assertFalse(grpo_learner.should_sync_weights) train_ds = _dummy_dataset(MySource(repeat=10), batch_size=2) @@ -1330,12 +1355,19 @@ def _patch_create_agent_env_pair(single_example, group_id): with mock.patch.object(rl_cluster, "generate", side_effect=_mock_generate): grpo_learner.train(train_ds, eval_ds) - variables = nnx.state(model, nnx.Param) - jax.tree.map_with_path( - test_common.assert_not_equal, original_variables, variables + traj = agents[0].trajectory + + target_mask = [] + for step in traj.steps: + # + 1 for extra token from MockChatParser + target_mask.extend([1] * (len(step.model_response.split()) + 1)) + target_mask.extend([0] * (len(step.observation.split()) + 1)) + target_mask.extend( + [0] * (grpo_config.max_response_length - len(target_mask)) ) - # TODO(tsbao): check on generated agents and envs once deepcopy is removed. + res = processed_results[0][0] + np.testing.assert_array_equal(res.completion_mask[0], np.array(target_mask)) if __name__ == "__main__": diff --git a/tests/sft/peft_trainer_test.py b/tests/sft/peft_trainer_test.py index 1a11c438..406d213b 100644 --- a/tests/sft/peft_trainer_test.py +++ b/tests/sft/peft_trainer_test.py @@ -14,6 +14,7 @@ """Peft trainer unittest.""" +import contextlib import functools import os import tempfile @@ -165,13 +166,20 @@ def test_basic_training(self, cache_nnx_graph: bool): trainer.train(self.train_ds) # No eval dataset. @parameterized.named_parameters( - ('lora_disabled', False), - ('lora_enabled', True), + ('lora_disabled_distributed', False, True), + ('lora_disabled_single_device', False, False), + ('lora_enabled_distributed', True, True), + ('lora_enabled_single_device', True, False), ) - def test_checkpoint_save_and_restore(self, enable_lora: bool): + def test_checkpoint_save_and_restore( + self, enable_lora: bool, distributed: bool + ): def create_model_and_optimizer(): rngs = nnx.Rngs(0) - model = tc.ToyTransformer(config=tc.ModelConfig(), rngs=rngs) + if distributed: + model, _ = create_sharded_model(tc.ToyTransformer, rngs, self.mesh) + else: + model = tc.ToyTransformer(config=tc.ModelConfig(), rngs=rngs) if enable_lora: model = tc.get_lora_model(model) @@ -194,7 +202,10 @@ def create_model_and_optimizer(): trainer = peft_trainer.PeftTrainer(model, optimizer, config) trainer = trainer.with_gen_model_input_fn(dummy_gen_model_input_fn) - trainer.train(self.train_ds, self.eval_ds, cache_nnx_graph=True) + ctx = self.mesh if distributed else contextlib.nullcontext() + + with ctx: + trainer.train(self.train_ds, self.eval_ds, cache_nnx_graph=True) trained_model_state = nnx.state( model, nnx.LoRAParam if enable_lora else nnx.Param ) @@ -223,6 +234,24 @@ def create_model_and_optimizer(): tc.assert_equal, trained_opt_state, resumed_opt_state ) + resumed_trainer = resumed_trainer.with_gen_model_input_fn( + dummy_gen_model_input_fn + ) + with ctx: + resumed_trainer.train(self.train_ds, self.eval_ds, cache_nnx_graph=True) + + resumed_opt_state = nnx.state( + resumed_trainer.optimizer, nnx.optimizer.OptState + ) + + jax.tree.map( + lambda x, y: self.assertTrue( + x.sharding.is_equivalent_to(y.sharding, ndim=x.ndim) + ), + trained_opt_state, + resumed_opt_state, + ) + def test_basic_training_with_hooks(self): train_ds = dummy_datasets(batch_size=4, repeat=2) config = peft_trainer.TrainingConfig(eval_every_n_steps=2, max_steps=100) diff --git a/tests/smoke_tests/model_creation_test.py b/tests/smoke_tests/model_creation_test.py index f8f67070..f3e93daa 100644 --- a/tests/smoke_tests/model_creation_test.py +++ b/tests/smoke_tests/model_creation_test.py @@ -55,9 +55,9 @@ def tearDown(self): ), dict( testcase_name="gemma2_2b_it", - model_name="gemma-2-2b-it", + model_name="gemma2_2b_it", model_source="kaggle", - model_id="google/gemma-2-2b-it", + model_id="gemma2_2b_it", model_path="google/gemma-2/flax/gemma2-2b-it", tokenizer_path=model._DEFAULT_TOKENIZER_PATH, tokenizer_type="sentencepiece", diff --git a/tunix/cli/base_config.yaml b/tunix/cli/base_config.yaml index 4233d5e0..b31f3441 100644 --- a/tunix/cli/base_config.yaml +++ b/tunix/cli/base_config.yaml @@ -143,10 +143,11 @@ training_config: &base_training_config run_name: "" log_dir: "/tmp/logging" flush_every_n_steps: 20 - perf_metrics_options: # Currently only supported for grpo_main. - enable_perf_metrics: false - custom_export_fn_path: "" - log_dir: "/tmp/perf_metrics" + # === Perf metrics options === + # Currently only supported for grpo_main. Configs you can specify are: + # log_dir = the directory to save the trace files. + # custom_export_fn_path = the path to the custom export function. + perf_metrics_options: {} profiler_options: log_dir: "/tmp/profiling" skip_first_n_steps: 1 diff --git a/tunix/cli/config.py b/tunix/cli/config.py index 01929bf0..49e83a25 100644 --- a/tunix/cli/config.py +++ b/tunix/cli/config.py @@ -211,7 +211,7 @@ def _validate_perf_metrics(self, entry_point: str): "perf_metrics_options", {} ) - if perf_config and perf_config.get("enable_perf_metrics", False): + if perf_config: if not entry_point.endswith("grpo_main"): raise ValueError( "Perf metrics are currently only supported for GRPO training" diff --git a/tunix/cli/grpo_main.py b/tunix/cli/grpo_main.py index 5b805680..909f5b99 100644 --- a/tunix/cli/grpo_main.py +++ b/tunix/cli/grpo_main.py @@ -92,7 +92,7 @@ def create_rl_training_config(self): def create_perf_config(self, cluster_config: rl_cluster_lib.ClusterConfig): perf_metrics_options = cluster_config.training_config.perf_metrics_options - if not perf_metrics_options or not perf_metrics_options.enable_perf_metrics: + if not perf_metrics_options: return None perf_config = perf_metrics.PerfMetricsConfig() diff --git a/tunix/distillation/feature_extraction/sowed_module.py b/tunix/distillation/feature_extraction/sowed_module.py index 54e01c1b..ccf533f8 100644 --- a/tunix/distillation/feature_extraction/sowed_module.py +++ b/tunix/distillation/feature_extraction/sowed_module.py @@ -14,12 +14,9 @@ """Utilities for wrapping nnx.Modules to capture their outputs.""" -import logging - +from absl import logging from flax import nnx -logger = logging.getLogger(__name__) - class SowedModule(nnx.Module): """Wraps an nnx.Module to capture its final output using `sow`. @@ -38,7 +35,7 @@ def __call__(self, *args, **kwargs): # Execute the wrapped model's forward pass output = self.wrapped_model(*args, **kwargs) # Sow the output into this wrapper's state - logger.debug( + logging.debug( "SowedModule sowing output for %s under tag '%s'", type(self.wrapped_model).__name__, self._SOW_TAG, diff --git a/tunix/generate/sampler.py b/tunix/generate/sampler.py index 11d9862e..5ede2c68 100644 --- a/tunix/generate/sampler.py +++ b/tunix/generate/sampler.py @@ -16,7 +16,7 @@ from __future__ import annotations -from collections.abc import Sequence +from collections.abc import Iterable, Sequence import dataclasses from typing import Any, Optional import warnings @@ -66,7 +66,7 @@ class _SamplingState: logits_buffer: jnp.ndarray | None # [B, L, V] # List of tokens that are forbidden to be generated. - forbidden_token_ids: Sequence[int] | None + forbidden_token_ids: tuple[int, ...] | None # Random seed for sampling. seed: jax.Array @@ -311,7 +311,7 @@ def init_sample_state( all_input_ids: jax.Array, total_sampling_steps: int, include_logits: bool, - forbidden_token_ids: Sequence[int] | None, + forbidden_token_ids: tuple[int, ...] | None, temperature: float, top_p: Optional[float], top_k: Optional[int], @@ -641,7 +641,7 @@ def __call__( echo: bool = False, return_logits: bool = False, eos_tokens: Sequence[int] | None = None, - forbidden_tokens: Sequence[str] | None = None, + forbidden_tokens: Iterable[int] | None = None, temperature: float = 0.0, top_p: Optional[float] = None, top_k: Optional[int] = None, @@ -665,8 +665,7 @@ def __call__( return_logits: whether to return per-step logits used during generation. eos_tokens: end of sequence tokens to stop generation. If None, the tokenizer's eos_id will be used. - forbidden_tokens: list of tokens that are forbidden to be generated. Each - token must map to a single token id in the vocab. + forbidden_tokens: Optional Iterable of token IDs that are disallowed. temperature: temperature for sampling. top_p: top-p sampling threshold. top_k: top-k sampling threshold. @@ -686,17 +685,7 @@ def __call__( [input_strings] if isinstance(input_strings, str) else input_strings ) - forbidden_token_ids = None - if forbidden_tokens is not None: - forbidden_token_ids = [] - for token in forbidden_tokens: - token_id = self.tokenizer.encode(token) - if len(token_id) != 1: - raise ValueError( - 'Forbidden tokens must map to single token ids in the vocab.' - ) - forbidden_token_ids.extend(token_id) - forbidden_token_ids = tuple(forbidden_token_ids) + forbidden_token_ids = tuple(forbidden_tokens) if forbidden_tokens else None tokens = [self.tokenize(x) for x in input_strings] max_tokens_length = max(len(x) for x in tokens) @@ -777,7 +766,6 @@ def __call__( else: out_tokens = [] out_logits = [] - lengths = [] for i, token_buffer in enumerate(token_buffers): start_idx = ( utils.find_first_non_pad_idx(token_buffer, self.tokenizer.pad_id()) @@ -793,7 +781,6 @@ def __call__( out_tokens.append(jax.device_get(token_buffer[start_idx:end_idx])) if return_logits: out_logits.append(logits_buffers[i][start_idx:end_idx]) - lengths.append(end_idx - start_idx) decoded_outputs = [ self.tokenizer.decode(tokens.tolist()) for tokens in out_tokens diff --git a/tunix/generate/sglang_jax_sampler.py b/tunix/generate/sglang_jax_sampler.py index 2c455311..a2ac053a 100644 --- a/tunix/generate/sglang_jax_sampler.py +++ b/tunix/generate/sglang_jax_sampler.py @@ -15,11 +15,10 @@ """Sampler for sglang-jax-style autoregressive decoding using JAX and NNX models.""" import dataclasses -import logging import math -import re -from typing import Any, Dict, Iterator, List, Optional, Tuple, Union +from typing import Any, Dict, List, Optional, Tuple, Union +from absl import logging from flax import nnx import jax import jax.numpy as jnp @@ -82,10 +81,13 @@ class SglangJaxConfig: precompile_token_paddings: Optional[List[int]] = None precompile_bs_paddings: Optional[List[int]] = None chunked_prefill_size: Optional[int] = -1 - page_size: int = 64 + page_size: int = 128 load_format: str = "auto" max_running_requests: int = None + # Logging knob to enable debugging at different verbosity levels. + log_level: str = "info" + class SglangJaxSampler(base_sampler.BaseSampler): # pylint: disable=invalid-name """A sampler for sglang-jax-style autoregressive decoding using JAX and NNX models. @@ -101,6 +103,7 @@ def __init__( self, tokenizer: Any, config: SglangJaxConfig, + **kwargs, ): """Initializes the SglangJaxSampler. @@ -110,6 +113,8 @@ def __init__( """ self.tokenizer = tok_adapter.TokenizerAdapter(tokenizer) self.args = self._sglang_jax_config(config) + if kwargs: + self.args.update(kwargs) self.engine = Engine(**self.args) self.to_hf_key_mappings = update_hf_key_mappings_with_lora( @@ -128,9 +133,7 @@ def __init__( config.mapping_config.lora_to_hf_transpose_keys ) - self._logger = logging.getLogger(self.__class__.__name__) - - self._logger.debug(f"{self.to_hf_key_mappings=}") + logging.debug(f"{self.to_hf_key_mappings=}") # TODO(b/434969743): Optimize weight sharing between trainer and sglang-jax sampler. # TODO(b/434975493): Consider Release KV cache on the fly @@ -194,6 +197,7 @@ def _sglang_jax_config(self, config: SglangJaxConfig): args["max_running_requests"] = config.max_running_requests args["enable_engine_loop_run_forever_daemon"] = True + args["log_level"] = config.log_level return args def _validate_config(self, config: SglangJaxConfig): @@ -277,6 +281,7 @@ def __call__( return_logits: bool = True, echo: bool = False, pad_output: bool = False, + **kwargs, ) -> base_sampler.SamplerOutput: # max_generation_steps: maximum number of tokens to generate if ( @@ -304,6 +309,24 @@ def __call__( self.sampling_params.top_p = top_p if top_k is not None: self.sampling_params.top_k = top_k + + if kwargs: + try: + self.sampling_params.update(**kwargs) + logging.log_first_n( + logging.INFO, + "Received additional kwargs that are not explicitly defined in the" + f" method signature: {kwargs}. These will be forwarded to the" + " underlying sampler, but please ensure that they are valid.", + 1, + ) + except Exception as e: + logging.log_first_n( + logging.INFO, + f"Failed to update sampling_params with kwargs: {kwargs}." + f" Error: {e}", 1 + ) + sampling_params = [ self.sampling_params.convert_to_dict() for _ in input_strings ] @@ -340,15 +363,8 @@ def __call__( all_input_ids = np.array(all_input_ids, dtype=np.int32) all_output_ids = [ - utils.pad_to_length( - np.array(x["output_ids"], dtype=np.int32), - target_length=max_generation_steps, - pad_value=self.tokenizer.pad_id(), - left=False, - ) - for x in outputs + np.array(x["output_ids"], dtype=np.int32) for x in outputs ] - all_output_ids = jnp.array(all_output_ids) output_texts = [o["text"] for o in outputs] # To support multisampling, just return the whole list of SamplerOutput return base_sampler.SamplerOutput( diff --git a/tunix/generate/utils.py b/tunix/generate/utils.py index 0c8963b5..60e92547 100644 --- a/tunix/generate/utils.py +++ b/tunix/generate/utils.py @@ -15,14 +15,16 @@ """Utility functions for sampler.""" +from collections import abc import functools import gc -import logging +from absl import logging import math import re from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Tuple from flax import nnx +from flax import traverse_util import jax from jax import lax import jax.numpy as jnp @@ -545,14 +547,22 @@ def _align_shape( # Handle rank mismatch if len(val.shape) != len(tgt_shape): if re.compile(r'layers\..*\.attn\.(q|k|v)_bias').match(src_key): - new_shape = (tgt_shape[0], val.shape[0] // tgt_shape[0]) - logging.debug( - 'Reshaping attention bias on %s: %s -> %s', - src_key, - val.shape, - new_shape, - ) - return jnp.reshape(val, new_shape) + if math.prod(tgt_shape) == math.prod(val.shape): + new_shape = (tgt_shape[0], val.shape[0] // tgt_shape[0]) + logging.debug( + 'Reshaping attention bias on %s: %s -> %s', + src_key, + val.shape, + new_shape, + ) + return jnp.reshape(val, new_shape) + else: + # If target pads number of heads, we need to reshape and then pad, we + # don't consider padding head dimensions here. + new_src_shape = (val.shape[0] // tgt_shape[1], tgt_shape[1]) + val = jnp.reshape(val, new_src_shape) + new_tgt_shape = tgt_shape + elif re.compile(r'layers\..*\.attn\.(q|k|v|o)_proj').match(src_key): if math.prod(tgt_shape) == math.prod(val.shape): logging.debug( @@ -756,6 +766,70 @@ def transfer_state_with_mappings( return dst_state.from_flat_path(tgt_flat_list) +def _slice_scanned_param( + src_val: jax.Array | np.ndarray | Any, + tgt_val: jax.Array | np.ndarray | Any, + slice_idx: int, + key_path: str, +) -> jax.Array | np.ndarray | Any: + """Slices a scanned parameter dynamically detecting the scan axis. + + This helper finds the dimension in src_val that needs to be sliced to match + tgt_val's shape. It is used when transferring weights from a scanned + representation (e.g., MaxText) to an unrolled one (e.g., vLLM). + + Args: + src_val: The source array (scanned) to slice from. + tgt_val: The target array whose shape we want to match. + slice_idx: The index along the scanned axis to extract. + key_path: The dot-separated path to the parameter for debugging. + + Returns: + The sliced array matching the target shape, or the original src_val if + slicing failed or was unnecessary. + """ + if not (hasattr(src_val, 'shape') and hasattr(tgt_val, 'shape')): + return src_val + + src_shape = src_val.shape + tgt_shape = tgt_val.shape + + if src_shape == tgt_shape: + return src_val + + if len(src_shape) == len(tgt_shape) + 1: + scan_axis = None + # Check which dimension, when removed, matches the target shape + for i in range(len(src_shape)): + if src_shape[:i] + src_shape[i + 1 :] == tgt_shape: + scan_axis = i + break + + if scan_axis is not None: + # Construct slice: (:, :, slice_idx, :, :) + slicer = [slice(None)] * len(src_shape) + slicer[scan_axis] = slice_idx + return src_val[tuple(slicer)] + + logging.warning( + "Shape mismatch in scanned param '%s'. Src: %s, Tgt: %s. Cannot" + ' determine scan axis.', + key_path, src_shape, tgt_shape, + ) + + # Fallback to direct slicing if the above logic fails, which may work for simple cases + try: + return src_val[slice_idx] + + except (IndexError, TypeError) as e: + logging.debug( + "Direct slicing fallback failed for '%s' (slice_idx=%d). " + "Error: %s. Using original value.", + key_path, slice_idx, e + ) + return src_val + + def transfer_state_directly( src_state: Mapping[str, Any], dst_state: Mapping[str, Any], @@ -783,14 +857,14 @@ def safe_has_key(obj: Mapping[str, Any], key: str) -> bool: return hasattr(obj, key) # Unwrap Source (Remove 'base' wrapper from MaxText) - if isinstance(src_state, (dict, nnx.State, nnx.Dict)) and safe_has_key( + if isinstance(src_state, abc.Mapping) and safe_has_key( src_state, 'base' ): logging.info("Unwrapping 'base' key from source state.") src_state = src_state['base'] # Unwrap Target (Remove nested 'model' wrappers from vLLM) - while isinstance(dst_state, (dict, nnx.State, nnx.Dict)) and safe_has_key( + while isinstance(dst_state, abc.Mapping) and safe_has_key( dst_state, 'model' ): logging.info("Unwrapping nested 'model' key from target state.") @@ -802,11 +876,9 @@ def to_pure_spec(node: Any) -> Any: # Unwrap NNX containers if hasattr(node, 'to_pure_dict'): node = node.to_pure_dict() - elif isinstance(node, (nnx.Dict, nnx.State)): - node = dict(node) # Recurse into dicts - if isinstance(node, dict): + if isinstance(node, abc.Mapping): return {k: to_pure_spec(v) for k, v in node.items()} # Unwrap Variables @@ -817,44 +889,95 @@ def to_pure_spec(node: Any) -> Any: return node - # Helper: Intersect Trees (Handle KVCache/RNG mismatches) def intersect_trees( - src: Any, tgt_spec: Any, path: str = '' - ) -> Tuple[Any, Any]: - # Stop recursion if we hit a leaf (non-dict) - if not isinstance(src, dict) or not isinstance(tgt_spec, dict): + src: Mapping[str, Any], + tgt_spec: Mapping[str, Any], + ) -> Tuple[Mapping[str, Any], Mapping[str, Any]]: + """Optimized intersection (Handle KVCache/RNG mismatches and Scanned Layers). + + Uses flat dictionary traversal for efficiency. + """ + # Fast path for non-dict inputs (leaves) + if not isinstance(src, abc.Mapping) or not isinstance(tgt_spec, abc.Mapping): return src, tgt_spec - src_keys = set(src.keys()) - tgt_keys = set(tgt_spec.keys()) - common_keys = src_keys & tgt_keys - - # Debug Logging for dropped keys - if src_keys - tgt_keys: - logging.debug( - "Ignored checkpoint keys at '%s': %s", path, src_keys - tgt_keys - ) - if tgt_keys - src_keys: - logging.debug( - "Unmatched model keys at '%s': %s", path, tgt_keys - src_keys - ) - - filtered_src = {} - filtered_tgt = {} - - for k in common_keys: - new_path = f'{path}/{k}' if path else k - s_val, t_val = intersect_trees(src[k], tgt_spec[k], new_path) - filtered_src[k] = s_val - filtered_tgt[k] = t_val - - return filtered_src, filtered_tgt + # Flatten both structures to (path_tuple) -> value + # usage of sep='/' is optional, but tuples are faster for manipulation + src_flat = traverse_util.flatten_dict(src) + tgt_flat = traverse_util.flatten_dict(tgt_spec) + + filtered_src_flat = {} + filtered_tgt_flat = {} + + # Compile regex once + layer_pattern = re.compile(r'^layers_(\d+)$') + + for key_tuple, tgt_val in tgt_flat.items(): + # Try Direct Match + if key_tuple in src_flat: + src_val = src_flat[key_tuple] + src_val = _apply_dtype_cast(src_val, tgt_val.dtype, str(key_tuple)) + filtered_src_flat[key_tuple] = src_val + filtered_tgt_flat[key_tuple] = tgt_val + continue + + # Try Scanned Layer Mapping + # We look for 'layers_X' in the path and try to map it to 'layers' (MaxText) + # or remove it (GPT-OSS / implicit stack). + + # Locate which part of the path is 'layers_X' + layer_idx = -1 + match_index = -1 + + for i, part in enumerate(key_tuple): + # Optimization: Only check strings that look like layers + if isinstance(part, str) and part.startswith('layers_'): + m = layer_pattern.match(part) + if m: + layer_idx = int(m.group(1)) + match_index = i + break + + if match_index != -1: + # Check different candidate path formats for scanned layers + # Candidate A: Replace 'layers_X' with 'layers' (Standard MaxText) + candidate_a = list(key_tuple) + candidate_a[match_index] = 'layers' + + # Candidate B: Remove 'layers_X' (Implicit Container / GPT-OSS) + candidate_b = list(key_tuple) + candidate_b.pop(match_index) + + found_candidate = None + for cand in [tuple(candidate_a), tuple(candidate_b)]: + if cand in src_flat: + found_candidate = cand + break + + if found_candidate: + src_val = src_flat[found_candidate] + # Slice the scanned parameter + sliced_val = _slice_scanned_param( + src_val, tgt_val, layer_idx, str(key_tuple) + ) + sliced_val = _apply_dtype_cast( + sliced_val, tgt_val.dtype, str(key_tuple) + ) + filtered_src_flat[key_tuple] = sliced_val + filtered_tgt_flat[key_tuple] = tgt_val + continue + + # Unflatten back to nested structure + return ( + traverse_util.unflatten_dict(filtered_src_flat), + traverse_util.unflatten_dict(filtered_tgt_flat), + ) # Prepare clean source and target specs full_source_dict = to_pure_spec(src_state) full_target_spec = to_pure_spec(dst_state) - # Filter both to their intersection + # Filter both to their intersection / mapping final_source, final_spec = intersect_trees(full_source_dict, full_target_spec) # Reshard and Update @@ -864,6 +987,9 @@ def intersect_trees( ) nnx.update(dst_state, resharded_weights) + # Explicitly free memory + gc.collect() + def verify_state_closeness(golden_state, state, atol=1e-2): """Check if the golden NNX state is close to the other NNX state. diff --git a/tunix/generate/vllm_async_driver.py b/tunix/generate/vllm_async_driver.py index 6dba9434..736ca86d 100644 --- a/tunix/generate/vllm_async_driver.py +++ b/tunix/generate/vllm_async_driver.py @@ -22,12 +22,12 @@ from __future__ import annotations from concurrent.futures import Future -from absl import logging import os import threading import time from typing import Any, Callable, Dict, Optional, Union +from absl import logging from vllm import envs from vllm.engine.arg_utils import EngineArgs from vllm.inputs import PromptType @@ -57,6 +57,7 @@ def __init__( llm_engine: LLMEngine, *, poll_interval_s: float = 0.005, + log_stats_interval_s: float = 10.0, stream_callback: Optional[StreamCallback] = None, auto_start: bool = True, ) -> None: @@ -68,9 +69,11 @@ def __init__( self._work_event = threading.Event() self._stop_event = threading.Event() self._loop_thread: Optional[threading.Thread] = None + self._log_thread: Optional[threading.Thread] = None + self._log_stats_interval_s: float = log_stats_interval_s self._pending: Dict[str, RequestFuture] = {} - self._last_error: Optional[BaseException] = None + self._last_error: Optional[Exception] = None if auto_start: self.start() @@ -82,10 +85,14 @@ def from_engine_args( *, usage_context: UsageContext = UsageContext.ENGINE_CONTEXT, poll_interval_s: float = 0.005, + log_stats_interval_s: float = 1.0, stream_callback: Optional[StreamCallback] = None, auto_start: bool = True, ) -> "VLLMInProcessDriver": - logging.debug(f"Creating VLLMInProcessDriver with engine_args: {engine_args} and usage_context: {usage_context}") + logging.debug( + f"Creating VLLMInProcessDriver with engine_args: {engine_args} and" + f" usage_context: {usage_context}" + ) llm_engine = LLMEngine.from_engine_args( engine_args, usage_context=usage_context, @@ -115,7 +122,10 @@ def submit_request( if request_id in self._pending: raise ValueError(f"Request {request_id} already pending.") self._pending[request_id] = future - logging.debug(f"VLLMInProcessDriver submitting request {request_id} with prompt {prompt} and sampling params {params} to vLLM engine.") + logging.debug( + f"VLLMInProcessDriver submitting request {request_id} with prompt" + f" {prompt} and sampling params {params} to vLLM engine." + ) self._llm_engine.add_request( request_id=request_id, prompt=prompt, @@ -138,6 +148,19 @@ def start(self) -> None: ) self._loop_thread.start() + self._log_thread = threading.Thread( + target=self._log_loop, name="VLLMLogStats", daemon=True + ) + self._log_thread.start() + + def _log_loop(self) -> None: + while not self._stop_event.is_set(): + try: + self._llm_engine.do_log_stats() + except Exception: # pylint: disable=broad-exception-caught + logging.exception("log_stats failed") + self._stop_event.wait(self._log_stats_interval_s) + def cancel(self, request_id: str) -> None: with self._engine_lock: future = self._pending.pop(request_id, None) @@ -164,6 +187,9 @@ def stop(self) -> None: if self._loop_thread is not None: self._loop_thread.join() self._loop_thread = None + if self._log_thread is not None: + self._log_thread.join() + self._log_thread = None def pause(self) -> None: raise RuntimeError("Pause feature WIP") @@ -177,13 +203,18 @@ def _loop(self) -> None: if not self._wait_for_work(): continue outputs = self._step_engine() - logging.log_every_n(logging.DEBUG, f"VLLMInProcessDriver loop step outputs: {[output.request_id for output in outputs]}", 40) + logging.log_every_n( + logging.DEBUG, + "VLLMInProcessDriver loop step outputs:" + f" {[output.request_id for output in outputs]}", + 40, + ) if outputs: for output in outputs: self._handle_output(output) else: time.sleep(self._poll_interval_s) - except BaseException as exc: # pylint: disable=broad-exception-caught + except Exception as exc: # pylint: disable=broad-exception-caught self._record_error(exc) def _wait_for_work(self) -> bool: @@ -199,9 +230,19 @@ def _wait_for_work(self) -> bool: def _step_engine( self, ) -> list[Union[RequestOutput, PoolingRequestOutput]]: - logging.log_every_n(logging.DEBUG, f"VLLMInProcessDriver loop waking up to process one step of requests.", 100) + logging.log_every_n( + logging.DEBUG, + f"VLLMInProcessDriver loop waking up to process one step of requests.", + 100, + ) with self._engine_lock: - logging.log_every_n(logging.DEBUG, f"VLLMInProcessDriver has {self._llm_engine.get_num_unfinished_requests()} pending requests.", 100) + logging.log_every_n( + logging.DEBUG, + "VLLMInProcessDriver has" + f" {self._llm_engine.get_num_unfinished_requests()} pending" + " requests.", + 100, + ) if self._llm_engine.has_unfinished_requests(): return self._llm_engine.step() return [] @@ -218,10 +259,12 @@ def _handle_output( future = self._pending.pop(output.request_id, None) if future is None or future.done(): return - logging.debug(f"VLLMInProcessDriver completed request id: {output.request_id}.") + logging.debug( + f"VLLMInProcessDriver completed request id: {output.request_id}." + ) future.set_result(output) - def _record_error(self, exc: BaseException) -> None: + def _record_error(self, exc: Exception) -> None: logging.debug("VLLMInProcessDriver encountered an error: %s", exc) self._last_error = exc with self._engine_lock: @@ -236,7 +279,7 @@ def llm_engine(self) -> LLMEngine: return self._llm_engine @property - def last_error(self) -> Optional[BaseException]: + def last_error(self) -> Optional[Exception]: return self._last_error def __enter__(self) -> "VLLMInProcessDriver": diff --git a/tunix/generate/vllm_sampler.py b/tunix/generate/vllm_sampler.py index e82a32d1..8cfc2d04 100644 --- a/tunix/generate/vllm_sampler.py +++ b/tunix/generate/vllm_sampler.py @@ -46,31 +46,44 @@ class VllmConfig: """Vllm rollout configuations.""" - model_version: str - max_model_len: int - mesh: jax.sharding.Mesh - hbm_utilization: float - init_with_random_weights: bool - tpu_backend_type: str - mapping_config: MappingConfig - # The size of the CPU swap space to use for the KV cache, in GiB. - # This allows vLLM to offload KV cache blocks from TPU/GPU memory (HBM) to - # CPU memory (RAM) when HBM is full. - # A larger swap space allows for larger batch sizes and longer sequences - # than what can fit in HBM alone, potentially increasing throughput. - # However, frequent swapping can increase latency due to the overhead of - # transferring data between CPU and TPU/GPU memory. - swap_space: float = 4.0 # in GiB - lora_config: Optional[Dict[str, Any]] = None + # Sampler related server_mode: bool = False - async_scheduling: bool = False - tensor_parallel_size: int = -1 - data_parallel_size: int = -1 - enable_dp_attention: bool = False - max_num_batched_tokens: Optional[int] = None - max_num_seqs: Optional[int] = None - hf_config_path: Optional[Dict[str, Any]] = None + mapping_config: MappingConfig = dataclasses.field( + default_factory=MappingConfig + ) + + # vLLM Env vars + init_with_random_weights: bool = True + tpu_backend_type: str = "jax" + + # vLLM engine arg related, requires additional processing before passing into engine additional_config: Optional[Dict[str, Any]] = None + enable_dp_attention: bool = False + hbm_utilization: float = 0.5 + lora_config: Optional[Dict[str, Any]] = None + mesh: jax.sharding.Mesh = None + data_parallel_size: int = -1 + tensor_parallel_size: int = -1 + + # vLLM engine args that can be directly passed in without additional processing, e.g. max_model_len, async_scheduling, etc. + engine_kwargs: dataclasses.InitVar[Optional[Dict[str, Any]]] = None + _processed_engine_kwargs: Dict[str, Any] = dataclasses.field( + init=False, default_factory=dict + ) + + def __post_init__(self, engine_kwargs: Optional[Dict[str, Any]]): + engine_kwargs = engine_kwargs or {} + self._processed_engine_kwargs = engine_kwargs + if engine_kwargs: + for key, value in engine_kwargs.items(): + if hasattr(self, key): + logging.warning( + f"Engine kwargs contains key '{key}' which conflicts with an" + " existing attribute. The engine kwargs will be ignored for this" + " key." + ) + else: + setattr(self, key, value) class VllmSampler(base_sampler.BaseSampler): # pylint: disable=invalid-name @@ -197,6 +210,8 @@ def _find_total_size(self, mesh: jax.sharding.Mesh) -> int: def _vllm_config(self, config: VllmConfig): """Setup vllm config from Tunix Vllm config.""" + args = config._processed_engine_kwargs.copy() + tensor_parallel_size = config.tensor_parallel_size data_parallel_size = config.data_parallel_size total_mesh_devices = self._find_total_size(config.mesh) @@ -209,31 +224,23 @@ def _vllm_config(self, config: VllmConfig): elif config.data_parallel_size == -1: data_parallel_size = total_mesh_devices // tensor_parallel_size - args = {} + args["data_parallel_size"] = data_parallel_size + args["tensor_parallel_size"] = tensor_parallel_size + # Init vLLM model with random weights to speed up bootstrap time, because # model weights are synced from trainer later on if config.init_with_random_weights: args["load_format"] = "dummy" - args["model"] = config.model_version - args["max_model_len"] = config.max_model_len args["gpu_memory_utilization"] = config.hbm_utilization - args["swap_space"] = config.swap_space - args["data_parallel_size"] = data_parallel_size - args["tensor_parallel_size"] = tensor_parallel_size - args["async_scheduling"] = config.async_scheduling - - if config.max_num_batched_tokens is not None: - args["max_num_batched_tokens"] = config.max_num_batched_tokens - - if config.max_num_seqs is not None: - args["max_num_seqs"] = config.max_num_seqs + args["additional_config"] = config.additional_config or {} - args["additional_config"] = {} if config.lora_config is not None: args["additional_config"]["lora_config"] = config.lora_config + device_indexes = config.mesh.device_ids.flatten().tolist() + args["additional_config"]["sharding"] = { "sharding_strategy": { "device_indexes": device_indexes, @@ -241,14 +248,6 @@ def _vllm_config(self, config: VllmConfig): } } - # Add support for "hf_config_path" and "additional_config" which are - # directly passed to vLLM engine and part of the vLLM config contract. - if config.hf_config_path: - args["hf_config_path"] = config.hf_config_path - - if config.additional_config: - args["additional_config"].update(config.additional_config) - return args def _build_engine_args(self) -> EngineArgs: @@ -320,7 +319,9 @@ def detokenize( single_output.token_ids = single_output.token_ids[:-1] single_output.logprobs = single_output.logprobs[:-1] - out_tokens[idx].append(single_output.token_ids) + out_tokens[idx].append( + np.array(single_output.token_ids, dtype=np.int32) + ) decoded_outputs[idx].append( self.tokenizer.decode(single_output.token_ids) ) @@ -381,6 +382,7 @@ def __call__( return_logits: bool = True, echo: bool = False, pad_output: bool = False, + **kwargs, ) -> base_sampler.SamplerOutput: """The entry point API for vLLM Sampler""" if isinstance(input_strings, str): @@ -426,6 +428,24 @@ def __call__( if top_k is not None: sampling_params.top_k = top_k + if kwargs: + try: + sampling_params.update(**kwargs) + logging.log_first_n( + logging.INFO, + "Received additional kwargs that are not explicitly defined in" + f" the method signature: {kwargs}. These will be forwarded to the" + " underlying sampler, but please ensure that they are valid.", + 1, + ) + except Exception as e: + logging.log_first_n( + logging.INFO, + f"Failed to update sampling_params with kwargs: {kwargs}." + f" Error: {e}", + 1, + ) + self.sampling_params = sampling_params prompt_ids = [self.tokenize(x) for x in input_strings] @@ -457,20 +477,11 @@ def __call__( ] all_input_ids = np.array(all_input_ids, dtype=np.int32) - all_output_ids = [ - utils.pad_to_length( - np.array(x, dtype=np.int32), - target_length=max_generation_steps, - pad_value=self.tokenizer.pad_id(), - left=False, - ) - for x in out_tokens[0] - ] # To support multisampling, just return the whole list of SamplerOutput return base_sampler.SamplerOutput( text=decoded_outputs[0], logits=None, - tokens=all_output_ids, + tokens=out_tokens[0], padded_prompt_tokens=all_input_ids, logprobs=out_logprobs[0], ) diff --git a/tunix/models/automodel.py b/tunix/models/automodel.py index 8ef1a9c9..07817b77 100644 --- a/tunix/models/automodel.py +++ b/tunix/models/automodel.py @@ -148,8 +148,25 @@ def create_gemma_model_with_nnx_conversion( intermediate_ckpt_dir: str, rng_seed: int, mesh: jax.sharding.Mesh, + model_path: str | None = None, ) -> tuple[nnx.Module, Any]: - """Creates a Gemma model with NNX conversion, using a cached checkpoint if available.""" + """Creates a Gemma model with NNX conversion, using a cached checkpoint if available. + + Args: + model_name: The name of the model (e.g., "gemma-2b"). + ckpt_path: The base path to the checkpoints. + intermediate_ckpt_dir: Directory to save or load the NNX converted + checkpoint. + rng_seed: The random seed for model initialization. + mesh: Mesh object for device layout. + model_path: Optional. The specific path to the model files. If None, + the path is inferred from `model_name` and `ckpt_path`. + + Returns: + A tuple containing: + - model: The loaded nnx.Module. + - model_params: The model parameters. + """ def _nnx_convert_and_reload() -> tuple[nnx.Module, Any]: """Converts the model to an NNX checkpoint and reloads it. @@ -157,13 +174,26 @@ def _nnx_convert_and_reload() -> tuple[nnx.Module, Any]: This is a workaround, as the checkpoints on Kaggle don't work with NNX. This takes a long time. Skip if conversion is not needed. """ - if model_name.startswith('gemma-2'): - params_path = os.path.join( - ckpt_path, model_name.replace('gemma-2', 'gemma2') + if model_path: + dir_name = os.path.basename(model_path) + else: + # If model_path is not provided, fall back to inferring from model_name + logging.warning( + 'model_path is not provided. Inferring from model_name. This may lead' + ' to incorrect results if the model_name (%s) is not a standard Gemma' + ' model name.', model_name ) - else: # gemma - suffix = '-'.join(model_name.split('-')[1:]) - params_path = os.path.join(ckpt_path, suffix) + naming_info = naming.ModelNaming(model_name=model_name) + version_dashed = naming_info.model_version.replace('_', '-') + + if naming_info.model_family == 'gemma2': + dir_name = f'gemma2-{version_dashed}' + elif naming_info.model_family == 'gemma1p1': + dir_name = f'1.1-{version_dashed}' + else: # gemma + dir_name = version_dashed + + params_path = os.path.join(ckpt_path, dir_name) model, params = create_gemma_model_from_params(params_path, model_name) @@ -419,6 +449,7 @@ def from_pretrained( intermediate_ckpt_dir=intermediate_ckpt_dir, rng_seed=rng_seed, mesh=mesh, + model_path=model_path, ) elif model_source == ModelSource.INTERNAL: model, model_params = create_gemma_model_from_params( diff --git a/tunix/models/naming.py b/tunix/models/naming.py index efab0558..112a132b 100644 --- a/tunix/models/naming.py +++ b/tunix/models/naming.py @@ -21,17 +21,30 @@ import dataclasses +from typing import NewType import immutabledict +HFModelId = NewType('HFModelId', str) +ConfigId = NewType('ConfigId', str) + + +def _is_hf_model_id_type(model_id_or_name: str) -> bool: + return '-' in model_id_or_name or '.' in model_id_or_name + + +def _is_config_id_type(model_id_or_name: str) -> bool: + return not _is_hf_model_id_type(model_id_or_name) and '_' in model_id_or_name + + @dataclasses.dataclass(frozen=True) class ModelNaming: """Model naming information. Attributes: - model_id: The full model name identifier (case sensitive), as it appears on - Huggingface, including the parent directory. - E.g.,"meta-llama/Llama-3.1-8B". + model_id: A unique identifier for the model, which can be either a + Huggingface model ID (e.g., "meta-llama/Llama-3.1-8B") or a standardized + ConfigId (e.g., "llama3p1_8b"). model_name: The unique full name identifier of the model. This should be the full name and should match exactly with the model name used in Hugging Face. e.g., "gemma-2b","llama-3.1-8b". The model name is all lowercase and @@ -53,8 +66,9 @@ class ModelNaming: model version, used in the ModelConfig class. e.g., "gemma_2b_it" or "qwen2p5_0p5b". """ - - model_id: str | None = None + # TODO(b/451662153): use HFModelId and ConfigId throughout, add validation, + # and then remove str support. + model_id: HFModelId | ConfigId | str | None = None model_name: str | None = None model_family: str = dataclasses.field(init=False) model_version: str = dataclasses.field(init=False) @@ -97,10 +111,8 @@ class _ModelFamilyInfo: config_category: str # category in the path to the ModelConfig class -# Mapping of all model families from the hugging face model id to the internal -# model_family and config_category. Key is the prefix of the hugging face model -# id and value is the internal model family and config_category. -_MODEL_FAMILY_INFO_MAPPING = immutabledict.immutabledict({ +# HF model family info mapping. +_HF_MODEL_FAMILY_INFO_MAPPING = immutabledict.immutabledict({ 'gemma-': _ModelFamilyInfo(family='gemma', config_category='gemma'), 'gemma1.1-': _ModelFamilyInfo(family='gemma1p1', config_category='gemma'), 'gemma-1.1-': _ModelFamilyInfo(family='gemma1p1', config_category='gemma'), @@ -121,12 +133,43 @@ class _ModelFamilyInfo: ), }) +# Config id model family info mapping. +_CONFIG_ID_MODEL_FAMILY_INFO_MAPPING = immutabledict.immutabledict({ + 'gemma_': _ModelFamilyInfo(family='gemma', config_category='gemma'), + 'gemma1p1_': _ModelFamilyInfo(family='gemma1p1', config_category='gemma'), + 'gemma2_': _ModelFamilyInfo(family='gemma2', config_category='gemma'), + 'gemma3_': _ModelFamilyInfo(family='gemma3', config_category='gemma3'), + 'llama3_': _ModelFamilyInfo(family='llama3', config_category='llama3'), + 'llama3p1_': _ModelFamilyInfo(family='llama3p1', config_category='llama3'), + 'llama3p2_': _ModelFamilyInfo(family='llama3p2', config_category='llama3'), + 'qwen2p5_': _ModelFamilyInfo(family='qwen2p5', config_category='qwen2'), + 'qwen3_': _ModelFamilyInfo(family='qwen3', config_category='qwen3'), + 'deepseek_r1_distill_qwen_': _ModelFamilyInfo( + family='deepseek_r1_distill_qwen', config_category='qwen2' + ), +}) + + +def _get_model_family_mapping( + model_name: str, +) -> immutabledict.immutabledict[str, _ModelFamilyInfo]: + """Returns the model family mapping based on the model name format.""" + if _is_hf_model_id_type(model_name): + return _HF_MODEL_FAMILY_INFO_MAPPING + elif _is_config_id_type(model_name): + return _CONFIG_ID_MODEL_FAMILY_INFO_MAPPING + else: + raise ValueError( + f'Invalid model ID format: {model_name!r}. Expected a Huggingface' + ' model ID or a ConfigId.' + ) + def split(model_name: str) -> tuple[str, str]: """Splits model name into model family and model version. Find the longest matching prefix of the model name in the - _MODEL_FAMILY_INFO_MAPPING. Returns the remaining string as the model version, + model family info mapping. Returns the remaining string as the model version, stripping leading hyphens. Args: @@ -136,8 +179,9 @@ def split(model_name: str) -> tuple[str, str]: A tuple containing the un-standardized model_family and model_version. """ model_name = model_name.lower() + mapping = _get_model_family_mapping(model_name) matched_family = '' - for family in _MODEL_FAMILY_INFO_MAPPING: + for family in mapping: if model_name.startswith(family) and len(family) > len(matched_family): matched_family = family if matched_family: @@ -146,7 +190,7 @@ def split(model_name: str) -> tuple[str, str]: raise ValueError( f'Could not determine model family for: {model_name}. Not one of the' ' known families:' - f' {list(_MODEL_FAMILY_INFO_MAPPING.keys())}' + f' {list(mapping.keys())}' ) @@ -181,7 +225,8 @@ def _standardize_model_version(raw_model_version: str) -> str: def get_model_family_and_version(model_name: str) -> tuple[str, str]: """Splits model name into internal, standardized model family and model version.""" raw_model_family, raw_model_version = split(model_name) - model_family = _MODEL_FAMILY_INFO_MAPPING[raw_model_family].family + mapping = _get_model_family_mapping(model_name) + model_family = mapping[raw_model_family].family model_version = _standardize_model_version(raw_model_version) return model_family, model_version @@ -189,7 +234,8 @@ def get_model_family_and_version(model_name: str) -> tuple[str, str]: def get_model_config_category(model_name: str) -> str: """Returns the model config category from the model family.""" raw_model_family, _ = split(model_name) - return _MODEL_FAMILY_INFO_MAPPING[raw_model_family].config_category + mapping = _get_model_family_mapping(model_name) + return mapping[raw_model_family].config_category def get_model_config_id(model_name: str) -> str: @@ -200,17 +246,18 @@ def get_model_config_id(model_name: str) -> str: return config_id -def get_model_name_from_model_id(model_id: str) -> str: +def get_model_name_from_model_id(model_id: HFModelId | ConfigId | str) -> str: """Extracts model name from model ID by taking the last part of path. Args: model_id: The full model name identifier, as it appears on huggingface, - including the parent directory. E.g., meta-llama/Llama-3.1-8B. + including the parent directory. E.g., meta-llama/Llama-3.1-8B. Can also be + the model_config_id directly, e.g., llama3p1_8b. Returns: The model_name string. """ - if '/' in model_id: + if _is_hf_model_id_type(model_id) or '/' in model_id: model_name = model_id.split('/')[-1].lower() if not model_name: raise ValueError( @@ -219,8 +266,9 @@ def get_model_name_from_model_id(model_id: str) -> str: if model_name.startswith('meta-llama-'): return model_name.replace('meta-llama-', 'llama-', 1) return model_name + elif _is_config_id_type(model_id): + return model_id.lower() else: - raise ValueError( - f'Invalid model ID format: {model_id!r}. Model ID should be in the' - ' format of /' - ) + # If the model_id is not a HFModelId or ConfigId, we assume it is already + # a model_name and convert it to lowercase to be consistent. + return model_id.lower() diff --git a/tunix/perf/export.py b/tunix/perf/export.py index 88fefb4d..920b52a8 100644 --- a/tunix/perf/export.py +++ b/tunix/perf/export.py @@ -18,9 +18,9 @@ import functools from typing import Callable +from typing import Protocol from absl import logging - import numpy as np from tunix.perf import metrics from tunix.perf import perfetto @@ -40,6 +40,16 @@ PerfettoTraceWriter = perfetto.PerfettoTraceWriter +class _GrpoExtractSpansFn(Protocol): + + def __call__( + self, query: PerfSpanQuery + ) -> tuple[ + bool, list[SpanGroup], list[Span], list[Span], list[SpanGroup], list[Span] + ]: + return (False, None, None, None, None, None) + + class PerfMetricsExport: """Provides helper functions to create metrics export functions. @@ -64,6 +74,8 @@ class PerfMetricsExport: def from_role_to_devices( role_to_devices: dict[str, list[str]], trace_writer: PerfettoTraceWriter | None = None, + log_rollout_time_at_micro_batch_level: bool = False, + log_actor_train_time_at_micro_batch_level: bool = False, ) -> MetricsExportFn: """Creates a metrics export function based on the role to devices mapping. @@ -72,6 +84,12 @@ def from_role_to_devices( identifiers. trace_writer: An optional PerfettoTraceWriter to log performance traces. If None, a default writer is created. + log_rollout_time_at_micro_batch_level: Whether to log rollout time at the + micro batch level. This is a temporary flag. It will be removed once + metrics are exported at the micro batch. + log_actor_train_time_at_micro_batch_level: Whether to log actor train time + at the micro batch level. This is a temporary flag. It will be removed + once metrics are exported at the micro batch. Returns: A callable function that takes a PerfSpanQuery and returns MetricsT. @@ -81,38 +99,61 @@ def from_role_to_devices( # If no trace writer is provided, create a default one. logging.info("Creating a default trace writer for metrics export.") trace_writer = PerfettoTraceWriter(None) + r2d = role_to_devices if r2d["rollout"] == r2d["actor"] == r2d["refer"]: logging.info( "Collecting perf metrics with rollout, actor and reference colocated." ) - return partial( - PerfMetricsExport._grpo_metrics_colocated, r2d, trace_writer - ) + export_fn = PerfMetricsExport._grpo_metrics_colocated elif r2d["rollout"] != r2d["actor"] == r2d["refer"]: logging.info( "Collecting perf metrics with rollout on one mesh, and actor and" " reference on another mesh." ) - return partial( - PerfMetricsExport._grpo_metrics_rollout_1_actor_2_reference_2, - r2d, - trace_writer, - ) + export_fn = PerfMetricsExport._grpo_metrics_rollout_1_actor_2_reference_2 elif r2d["rollout"] != r2d["actor"] != r2d["refer"]: logging.info( "Collecting perf metrics fully disaggregated: rollout, actor and" " reference on three different meshes." ) - return partial( - PerfMetricsExport._grpo_metrics_fully_disaggregated, r2d, trace_writer - ) + export_fn = PerfMetricsExport._grpo_metrics_fully_disaggregated else: raise ValueError("Unsupported mesh configuration.") + extract_spans_fn = partial( + PerfMetricsExport._grpo_extract_spans_and_groups, + role_to_devices=role_to_devices, + log_rollout_time_at_micro_batch_level=log_rollout_time_at_micro_batch_level, + log_actor_train_time_at_micro_batch_level=log_actor_train_time_at_micro_batch_level, + ) + return partial(export_fn, extract_spans_fn, trace_writer) + @staticmethod - def from_cluster_config(cluster_config: ClusterConfig) -> MetricsExportFn: - """Creates a metrics export function based on the mesh topology in cluster config.""" + def from_cluster_config( + cluster_config: ClusterConfig, + log_rollout_time_at_micro_batch_level: bool = False, + log_actor_train_time_at_micro_batch_level: bool = False, + ) -> MetricsExportFn: + """Creates a metrics export function based on the mesh topology in cluster config. + + This function extracts the device mappings from the `cluster_config` to + determine the mesh configuration (colocated, partially disaggregated, or + fully disaggregated) and returns the appropriate metrics export function. + + Args: + cluster_config: The cluster configuration containing role to mesh + mappings. + log_rollout_time_at_micro_batch_level: Whether to log rollout time at + micro batch level. This is a temporary flag. It will be removed once + metrics are exported at the micro batch. + log_actor_train_time_at_micro_batch_level: Whether to log actor train time + at micro batch level. This is a temporary flag. It will be removed once + metrics are exported at the micro batch. + + Returns: + A callable function that takes a PerfSpanQuery and returns MetricsT. + """ rollo_mesh = cluster_config.role_to_mesh[rl_cluster.Role.ROLLOUT] actor_mesh = cluster_config.role_to_mesh[rl_cluster.Role.ACTOR] @@ -141,6 +182,8 @@ def from_cluster_config(cluster_config: ClusterConfig) -> MetricsExportFn: "refer": list(refer_devices), }, trace_writer=PerfettoTraceWriter(export_dir), + log_rollout_time_at_micro_batch_level=log_rollout_time_at_micro_batch_level, + log_actor_train_time_at_micro_batch_level=log_actor_train_time_at_micro_batch_level, ) # TODO(yangmu): DEPRECATED: remove after all users use the new API. @@ -152,15 +195,14 @@ def create_metrics_export_fn( @staticmethod def _grpo_metrics_colocated( - role_to_devices: dict[str, list[str]], + extract_spans_fn: _GrpoExtractSpansFn, trace_writer: PerfettoTraceWriter, query: PerfSpanQuery, ) -> MetricsT: """GRPO workflow: rollout, actor and reference are colocated on the same mesh. Args: - role_to_devices: A dictionary mapping role names to a list of device - identifiers. + extract_spans_fn: A callable to extract spans and span groups. trace_writer: A PerfettoTraceWriter to log performance traces. query: The PerfSpanQuery object to extract spans from. @@ -171,15 +213,18 @@ def _grpo_metrics_colocated( ( ok, - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, actor_train_step_spans, - ) = PerfMetricsExport._grpo_extract_spans_and_groups(role_to_devices, query) + ) = extract_spans_fn(query=query) if not ok: return {} + if not global_step_groups: + raise ValueError("global_step_groups is empty") + global_step_group = global_step_groups[0] weight_sync_span = global_step_group.find_last_inner_span("weight_sync") # If weight sync is skipped (due to shared model), create a zero duration # span for metrics computation. @@ -207,7 +252,7 @@ def _grpo_metrics_colocated( ] trace_writer.log_trace( - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, @@ -230,7 +275,7 @@ def _grpo_metrics_colocated( @staticmethod def _grpo_metrics_rollout_1_actor_2_reference_2( - role_to_devices: dict[str, list[str]], + extract_spans_fn: _GrpoExtractSpansFn, trace_writer: PerfettoTraceWriter, query: PerfSpanQuery, ) -> MetricsT: @@ -249,15 +294,18 @@ def _grpo_metrics_rollout_1_actor_2_reference_2( ( ok, - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, actor_train_step_spans, - ) = PerfMetricsExport._grpo_extract_spans_and_groups(role_to_devices, query) + ) = extract_spans_fn(query=query) if not ok: return {} + if not global_step_groups: + raise ValueError("global_step_groups is empty") + global_step_group = global_step_groups[0] weight_sync_span = global_step_group.find_last_inner_span("weight_sync") # If weight sync is skipped (due to shared model), create a zero duration # span for metrics computation. @@ -296,7 +344,7 @@ def _grpo_metrics_rollout_1_actor_2_reference_2( ] + [0.0] trace_writer.log_trace( - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, @@ -323,7 +371,7 @@ def _grpo_metrics_rollout_1_actor_2_reference_2( @staticmethod def _grpo_metrics_fully_disaggregated( - role_to_devices: dict[str, list[str]], + extract_spans_fn: _GrpoExtractSpansFn, trace_writer: PerfettoTraceWriter, query: PerfSpanQuery, ) -> MetricsT: @@ -342,15 +390,18 @@ def _grpo_metrics_fully_disaggregated( ( ok, - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, actor_train_step_spans, - ) = PerfMetricsExport._grpo_extract_spans_and_groups(role_to_devices, query) + ) = extract_spans_fn(query=query) if not ok: return {} + if not global_step_groups: + raise ValueError("global_step_groups is empty") + global_step_group = global_step_groups[0] weight_sync_span = global_step_group.find_last_inner_span("weight_sync") if weight_sync_span is None: logging.warning("weight_sync is None") @@ -392,7 +443,7 @@ def _grpo_metrics_fully_disaggregated( ] + [0.0] trace_writer.log_trace( - global_step_group, + global_step_groups, rollout_spans, refer_inference_spans, actor_train_groups, @@ -421,20 +472,34 @@ def _grpo_metrics_fully_disaggregated( @staticmethod def _grpo_extract_spans_and_groups( - role_to_devices: dict[str, list[str]], query: PerfSpanQuery + role_to_devices: dict[str, list[str]], + *, # force keyword arguments + log_rollout_time_at_micro_batch_level: bool, + log_actor_train_time_at_micro_batch_level: bool, + query: PerfSpanQuery, ) -> tuple[ - bool, SpanGroup, list[Span], list[Span], list[SpanGroup], list[Span] + bool, list[SpanGroup], list[Span], list[Span], list[SpanGroup], list[Span] ]: """Extracts spans and span groups of the last global step for GRPO workflow.""" - global_steps: list[SpanGroup] = ( - query().main().last_group("global_step").get() + # Get all global step groups from all host threads. The first + # global step group is the one from the main thread. + global_step_groups: list[SpanGroup] = [] + main_thread_id = query.get_main_thread_id() + host_timelines = [main_thread_id] + sorted( + tid + for tid in query.get_timeline_ids() + if tid != main_thread_id and tid.startswith("thread-") ) - if not global_steps: - logging.warning("global_step is None") - return (False, SpanGroup(""), [], [], [], []) - global_step_group: SpanGroup = global_steps[0] + for tid in host_timelines: + gs = query().timeline(tid).last_group("global_step").get() + if gs: + global_step_groups.extend(gs) + + if not global_step_groups: + logging.warning("global_step is None") + return (False, [SpanGroup("")], [], [], [], []) micro_batch: PerfSpanQuery = ( query() @@ -449,7 +514,7 @@ def _grpo_extract_spans_and_groups( if not rollout_groups or not refer_groups or not actor_groups: logging.warning("rollout_group or refer_group or actor_group is None") - return (False, SpanGroup(""), [], [], [], []) + return (False, [SpanGroup("")], [], [], [], []) rollout_span: list[Span] = [] refer_inference_span: list[Span] = [] @@ -474,9 +539,26 @@ def _grpo_extract_spans_and_groups( actor_train_group.find_all_inner_spans("peft_train_step") ) + if ( + log_actor_train_time_at_micro_batch_level + or log_rollout_time_at_micro_batch_level + ): + global_step_index: int = len( + query().main().all_groups("global_step").get() + ) + logging.info("global step [%s]", global_step_index) + if log_actor_train_time_at_micro_batch_level: + for i, time in enumerate( + [group.duration for group in actor_train_groups] + ): + logging.info("actor train time [%s] = %s sec", i, time) + if log_rollout_time_at_micro_batch_level: + for i, time in enumerate([span.duration for span in rollout_span]): + logging.info("rollout time [%s] = %s sec", i, time) + return ( True, - global_step_group, + global_step_groups, rollout_span, refer_inference_span, actor_train_groups, diff --git a/tunix/perf/metrics.py b/tunix/perf/metrics.py index c058c96b..b7c88548 100644 --- a/tunix/perf/metrics.py +++ b/tunix/perf/metrics.py @@ -73,9 +73,6 @@ class MetricsBuffer: @dataclasses.dataclass(frozen=True) class PerfMetricsOptions: - # Whether to enable performance metrics. If False, all other options will be - # ignored. - enable_perf_metrics: bool = False # Directory to write the raw metrics/events to. log_dir: str = "" # Path to the custom export function. If set, the custom export function will @@ -129,6 +126,12 @@ def __call__(self) -> PerfSpanQuery: query._select_groups = self._select_groups.copy() return query + def get_main_thread_id(self) -> str: + return self._main_thread_id + + def get_timeline_ids(self) -> list[str]: + return list(self._timelines.keys()) + def timeline(self, id: str) -> PerfSpanQuery: self._select_timeline = id return self diff --git a/tunix/perf/perfetto.py b/tunix/perf/perfetto.py index 452bebeb..3d7001e6 100644 --- a/tunix/perf/perfetto.py +++ b/tunix/perf/perfetto.py @@ -36,7 +36,7 @@ def _add_trace_events( *, builder: TraceProtoBuilder, - global_step_group: SpanGroup, + global_step_groups: list[SpanGroup], rollout_spans: list[Span], refer_inference_spans: list[Span], actor_train_groups: list[SpanGroup], @@ -45,7 +45,7 @@ def _add_trace_events( Args: builder: The TraceProtoBuilder to add events to. - global_step_group: A SpanGroup representing the global step. + global_step_groups: A list of SpanGroup representing the global steps. rollout_spans: A list of Spans for rollout operations. refer_inference_spans: A list of Spans for reference inference operations. actor_train_groups: A list of SpanGroups for actor training operations. @@ -58,13 +58,46 @@ def _add_trace_events( TrackDescriptor.ChildTracksOrdering.EXPLICIT ) + # Try to merge global_step_groups + merged_global_step: SpanGroup | Span | None = None + if global_step_groups: + try: + first_group, *other_groups = global_step_groups + merged_global_step = first_group + for g in other_groups: + merged_global_step = span.merge_span_group_trees(merged_global_step, g) + except ValueError: + logging.warning("Could not merge global step groups", exc_info=True) + merged_global_step = None + # Metadata for process names - # Main: uuid=1, Rollout: uuid=2, Reference: uuid=3, Actor: uuid=4 + # Main: 1 (merging all global steps), + # Main -- thread {i}: uuid=1000+i (if merging fails -- due to overlapping spans), + # Rollout: uuid=2000, Reference: uuid=2001, Actor: uuid=2002 + use_merged_main_track = merged_global_step and isinstance( + merged_global_step, SpanGroup + ) + + if use_merged_main_track: + packet = builder.add_packet() + packet.track_descriptor.uuid = 1 + packet.track_descriptor.name = "Main" + packet.track_descriptor.parent_uuid = ROOT_TRACK_UUID + packet.track_descriptor.sibling_order_rank = 1 + else: + # If no merged global step or it's not a SpanGroup, create a track for each + # global step thread. + for i, _ in enumerate(global_step_groups): + packet = builder.add_packet() + packet.track_descriptor.uuid = 1000 + i + packet.track_descriptor.name = f"Main -- thread {i}" + packet.track_descriptor.parent_uuid = ROOT_TRACK_UUID + packet.track_descriptor.sibling_order_rank = 1000 + i + for name, uuid in [ - ("Main", 1), - ("Rollout", 2), - ("Reference", 3), - ("Actor", 4), + ("Rollout", 2000), + ("Reference", 2001), + ("Actor", 2002), ]: packet = builder.add_packet() packet.track_descriptor.uuid = uuid @@ -97,19 +130,23 @@ def add_group(g: SpanGroup, track_uuid: int): add_span(inner, track_uuid) # Main - add_group(global_step_group, 1) + if use_merged_main_track: + add_group(merged_global_step, 1) + else: + for i, group in enumerate(global_step_groups): + add_group(group, 1000 + i) # Rollout for s in rollout_spans: - add_span(s, 2) + add_span(s, 2000) # Reference for s in refer_inference_spans: - add_span(s, 3) + add_span(s, 2001) # Actor for g in actor_train_groups: - add_group(g, 4) + add_group(g, 2002) class PerfettoTraceWriter: @@ -163,7 +200,7 @@ def write(self, builder: TraceProtoBuilder) -> None: def log_trace( self, - global_step_group: SpanGroup, + global_step_groups: list[SpanGroup], rollout_spans: list[Span], refer_inference_spans: list[Span], actor_train_groups: list[SpanGroup], @@ -171,15 +208,16 @@ def log_trace( """Generates and writes Perfetto trace events to a file. Args: - global_step_group: A SpanGroup representing the global step. + global_step_groups: A list of SpanGroup representing the global steps. rollout_spans: A list of Spans for rollout operations. refer_inference_spans: A list of Spans for reference inference operations. - actor_train_groups: A list of SpanGroups for actor training operations. + actor_train_groups: A list of SpanGroup for actor training operations. """ + builder = TraceProtoBuilder() _add_trace_events( builder=builder, - global_step_group=global_step_group, + global_step_groups=global_step_groups, rollout_spans=rollout_spans, refer_inference_spans=refer_inference_spans, actor_train_groups=actor_train_groups, diff --git a/tunix/perf/span.py b/tunix/perf/span.py index a8a5ec3c..790050d2 100644 --- a/tunix/perf/span.py +++ b/tunix/perf/span.py @@ -16,8 +16,12 @@ from __future__ import annotations +import math from typing import Any +from absl import logging + + JaxDevice = Any @@ -184,3 +188,133 @@ def span_group_batch_query_all( for group in batch: out_batch.extend(group.find_all_inner_groups(name)) return out_batch + + +def clone_span_or_group( + node: Span | SpanGroup, outer: SpanGroup | None = None +) -> Span | SpanGroup: + """Clones a span or span group recursively. + + Args: + node: The span or span group to clone. + outer: The parent span group to attach the cloned node to. + + Returns: + The cloned span or span group. + """ + if isinstance(node, SpanGroup): + new_group = SpanGroup(node.name, outer) + new_group.begin = node.begin + new_group.end = node.end + for child in node.inner: + clone_span_or_group(child, new_group) + return new_group + else: + new_span = Span(node.name, node.begin) + new_span.end = node.end + if outer is not None: + outer.inner.append(new_span) + return new_span + + +def _are_nodes_shallowly_identical( + node1: Span | SpanGroup, node2: Span | SpanGroup +) -> bool: + """Checks if two nodes are identical in type, name, start, and end. + + This only checks the root node, not the entire tree. + + Args: + node1: The first node to compare. + node2: The second node to compare. + + Returns: + True if the node roots are identical, False otherwise. + """ + + return ( + isinstance(node2, type(node1)) + and node1.name == node2.name + and math.isclose(node1.begin, node2.begin, rel_tol=1e-15, abs_tol=1e-9) + and math.isclose(node1.end, node2.end, rel_tol=1e-15, abs_tol=1e-9) + ) + + +def _merge_span_group_trees_inplace( + target: SpanGroup, source: SpanGroup +) -> None: + """Merges source into target in-place. + + Args: + target: The target span group tree (mutable). + source: The source span group tree (mutable). + + Raises: + ValueError: If overlapping nodes are not identical. + """ + # Append source children to target. Parent pointers are updated later. + for child in source.inner: + target.inner.append(child) + if isinstance(child, SpanGroup): + child.outer = target + + target.inner.sort(key=lambda x: x.begin) + + # Resolve overlaps + merged_inner = [] + if target.inner: + current = target.inner[0] + for next_node in target.inner[1:]: + if current.end > next_node.begin: + if _are_nodes_shallowly_identical(current, next_node): + if isinstance(current, SpanGroup) and isinstance( + next_node, SpanGroup + ): + _merge_span_group_trees_inplace(current, next_node) + # If Spans, keep current (drop duplicate next_node) + else: + raise ValueError( + f"Merge is not possible: Overlap detected between {current!r}" + f" and {next_node!r}" + ) + else: + merged_inner.append(current) + current = next_node + merged_inner.append(current) + + target.inner = merged_inner + + +def merge_span_group_trees( + tree1: SpanGroup | Span, tree2: SpanGroup | Span +) -> SpanGroup | Span: + """Merges two SpanGroup or Span trees into a new SpanGroup or Span. + + Validates that the input trees have identical root nodes and no overlapping + spans at the same level. Does not modify the input trees. + + Args: + tree1: The first SpanGroup or Span tree. + tree2: The second SpanGroup or Span tree. + + Returns: + A new SpanGroup or Span containing the merged result. + + Raises: + ValueError: If the roots are not identical or if the merge results in + overlapping spans. + """ + if not _are_nodes_shallowly_identical(tree1, tree2): + raise ValueError( + f"Roots are not identical: {tree1!r} vs {tree2!r}. Merge expected" + " identical roots." + ) + + target = clone_span_or_group(tree1) + source = clone_span_or_group(tree2) + + # Merge if both are SpanGroups. For Spans, simply return target. + if isinstance(target, SpanGroup) and isinstance(source, SpanGroup): + _merge_span_group_trees_inplace(target, source) + + return target diff --git a/tunix/perf/trace.py b/tunix/perf/trace.py index 5310b615..328c3ea6 100644 --- a/tunix/perf/trace.py +++ b/tunix/perf/trace.py @@ -41,11 +41,11 @@ from concurrent import futures import contextlib -import logging import threading import time from typing import Any, Callable +from absl import logging import jax import jaxtyping import numpy as np diff --git a/tunix/rl/agentic/agents/agent_types.py b/tunix/rl/agentic/agents/agent_types.py index 4ccb3131..9b19e55e 100644 --- a/tunix/rl/agentic/agents/agent_types.py +++ b/tunix/rl/agentic/agents/agent_types.py @@ -111,9 +111,9 @@ class TrajectoryItem: """Represents an item within a Trajectory, potentially for pairing or grouping. Attributes: - pair_index: Index for pairing. - group_id: Identifier for grouping trajectories. - episode_id: Unique identifier for the episode. + pair_index: Index of the trajectory within a group. + group_id: Identifier for grouping trajectories. By default, this is the row + index in the full dataset. start_step: The starting step index within the full trajectory. traj: The Trajectory object itself. metadata: Additional metadata. @@ -121,7 +121,6 @@ class TrajectoryItem: pair_index: int group_id: Hashable - episode_id: int start_step: int traj: Trajectory metadata: Dict[str, Any] = dataclasses.field(default_factory=dict) diff --git a/tunix/rl/agentic/agents/model_agent.py b/tunix/rl/agentic/agents/model_agent.py index c0e4dd35..032d1644 100644 --- a/tunix/rl/agentic/agents/model_agent.py +++ b/tunix/rl/agentic/agents/model_agent.py @@ -15,15 +15,11 @@ """Agent implementation for single-turn interactions.""" import copy -import logging from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.agents import base_agent -logger = logging.getLogger(__name__) - - class ModelAgent(base_agent.ConversationAgentBase): """Agent for single-turn interaction, responding directly to a task.""" diff --git a/tunix/rl/agentic/agents/tool_agent.py b/tunix/rl/agentic/agents/tool_agent.py index 8482ea62..2f892955 100644 --- a/tunix/rl/agentic/agents/tool_agent.py +++ b/tunix/rl/agentic/agents/tool_agent.py @@ -16,10 +16,10 @@ import copy import json -import logging from typing import Any, Dict import uuid +from absl import logging from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.agents import base_agent from tunix.rl.agentic.parser.tool_parser import tool_parser_base @@ -28,9 +28,6 @@ from tunix.rl.agentic.tools import tool_manager -logger = logging.getLogger(__name__) - - class ToolAgent(base_agent.ConversationAgentBase): """Agent implementation that supports tool usage within ConversationAgentBase. @@ -98,7 +95,7 @@ def _observation_to_messages( "content": observation["question"], }) else: - logger.warning("Unknown dict observation format: %s", observation) + logging.warning("Unknown dict observation format: %s", observation) elif isinstance(observation, str): self._messages.append({"role": "user", "content": observation}) @@ -126,7 +123,7 @@ def update_from_model(self, response: str, **kwargs) -> agent_types.Action: try: tool_calls = self.tool_parser.parse(response) except Exception as e: - logger.warning("ToolParser failed: %s", e) + logging.warning("ToolParser failed: %s", e) tool_calls = [] # Fallback mechanism: if no tool calls detected, use finish function. diff --git a/tunix/rl/agentic/environments/task_environment.py b/tunix/rl/agentic/environments/task_environment.py index 0f4b3608..c6377808 100644 --- a/tunix/rl/agentic/environments/task_environment.py +++ b/tunix/rl/agentic/environments/task_environment.py @@ -14,9 +14,9 @@ """RL Environment for single-turn task-based agent interactions.""" -import logging from typing import Any, Dict +from absl import logging from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.environments import base_environment from tunix.rl.agentic.rewards import reward @@ -52,10 +52,16 @@ def __init__( compatibility with a common environment config interface. """ if reward_fn is None: - logging.warning("No reward_fn provided, defaulting to dummy_reward().") + logging.log_first_n( + logging.WARNING, + "No reward_fn provided, defaulting to dummy_reward().", + 1, + ) reward_fn = reward.dummy_reward - super().__init__(task=single_example, reward_fn=reward_fn, max_steps=1, **kwargs) + super().__init__( + task=single_example, reward_fn=reward_fn, max_steps=1, **kwargs + ) def _initial_observation(self) -> Dict[str, Any]: """Reset the environment and return the task as the initial observation.""" diff --git a/tunix/rl/agentic/environments/tool_environment.py b/tunix/rl/agentic/environments/tool_environment.py index 93734cab..04b29d9c 100644 --- a/tunix/rl/agentic/environments/tool_environment.py +++ b/tunix/rl/agentic/environments/tool_environment.py @@ -21,10 +21,10 @@ """ import json -import logging from typing import Any, Dict, List import uuid +from absl import logging from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.environments import base_environment from tunix.rl.agentic.rewards import reward @@ -71,7 +71,11 @@ def __init__( **kwargs: Additional arguments reserved for future extensions. """ if reward_fn is None: - logging.warning("No reward_fn provided, defaulting to dummy_reward().") + logging.log_first_n( + logging.WARNING, + "No reward_fn provided, defaulting to dummy_reward().", + 1, + ) reward_fn = reward.dummy_reward # Let BaseTaskEnv handle task, reward_fn, step_count, and max_steps. diff --git a/tunix/rl/agentic/pipeline/rollout_orchestrator.py b/tunix/rl/agentic/pipeline/rollout_orchestrator.py index 9d8326af..1c607e1f 100644 --- a/tunix/rl/agentic/pipeline/rollout_orchestrator.py +++ b/tunix/rl/agentic/pipeline/rollout_orchestrator.py @@ -21,13 +21,13 @@ from __future__ import annotations -import traceback import asyncio from collections.abc import Hashable import copy -import logging +import traceback from typing import Any, AsyncIterable, Callable, Dict, Iterable, List, Optional, Tuple, Type +from absl import logging from tunix.rl.agentic import utils from tunix.rl.agentic.agents import agent_types from tunix.rl.agentic.agents import base_agent @@ -85,8 +85,7 @@ def __init__( self.max_concurrency = max_concurrency self._tasks: List[asyncio.Task] = [] self._stop = asyncio.Event() - self._logger = logging.getLogger(self.__class__.__name__) - self._manager: Optional[GroupQueueManager] = None + self._group_queue_manager: Optional[GroupQueueManager] = None self._rollout_sync_lock = rollout_sync_lock async def _collect_trajectory( @@ -107,38 +106,34 @@ async def _collect_trajectory( async def _run_and_queue_one_episode( self, - pair_idx: int, - episode_idx: int, agent: ConversationAgentBase, env: BaseTaskEnv, manager: GroupQueueManager, - group_key: Callable[[int, BaseTaskEnv, Trajectory], Hashable], + group_key_fn: Callable[[int, BaseTaskEnv, Trajectory], Hashable], start_step_fn: Optional[Callable[[], int]], collect_mode: Optional[str], ): """Collects one trajectory and queues it.""" + pair_idx = env.extra_kwargs["pair_index"] traj = await self._collect_trajectory(agent, env, mode=collect_mode) - gid = group_key(pair_idx, env, traj) + gid = group_key_fn(pair_idx, env, traj) start_step = start_step_fn() if start_step_fn else 0 item = TrajectoryItem( pair_index=pair_idx, group_id=gid, - episode_id=0, start_step=start_step, traj=traj, - metadata={"generation_id": episode_idx}, + metadata={"generation_id": pair_idx}, ) await manager.put(item) return 1 async def _runner( self, - i: int, agent: ConversationAgentBase, env: BaseTaskEnv, manager: GroupQueueManager, - group_key: Callable[[int, BaseTaskEnv, Trajectory], Hashable], - num_episodes: int = 1, + group_key_fn: Callable[[int, BaseTaskEnv, Trajectory], Hashable], start_step_fn: Optional[Callable[[], int]] = None, collect_mode: Optional[str] = None, ): @@ -150,55 +145,48 @@ async def _runner( `num_episodes` limit. Args: - i: The index of the agent-environment pair. agent: The ConversationAgentBase instance. env: The BaseTaskEnv instance. manager: The GroupQueueManager to put collected trajectories into. - group_key: A callable to determine the group ID for a trajectory. - num_episodes: The maximum number of episodes to collect for this pair, - defaults to 1. + group_key_fn: A callable to determine the group ID for a trajectory. start_step_fn: An optional callable to get the starting step for each trajectory item. collect_mode: An optional string to select the collection mode. """ episode_count = 0 - self._logger.debug( - "Starting generating trajectories(_runner) for pair %d", i + logging.debug( + "Starting generating trajectories(_runner) for pair %d", + env.extra_kwargs["pair_index"], ) try: # Parallel execution for the group self._rollout_sync_lock.acquire_rollout() try: - tasks = [] - async with asyncio.TaskGroup() as tg: - for ep_id in range(num_episodes): - # TODO(b/462779884): Replace deepcopy with a factory pattern. - task = tg.create_task( - self._run_and_queue_one_episode( - pair_idx=i, - episode_idx=ep_id, - agent=copy.deepcopy(agent), - env=copy.deepcopy(env), - manager=manager, - group_key=group_key, - start_step_fn=start_step_fn, - collect_mode=collect_mode, - ) - ) - tasks.append(task) - results = [task.result() for task in tasks] - episode_count = sum(results) + episode_count = await self._run_and_queue_one_episode( + agent=agent, + env=env, + manager=manager, + group_key_fn=group_key_fn, + start_step_fn=start_step_fn, + collect_mode=collect_mode, + ) finally: self._rollout_sync_lock.release_rollout() except ExceptionGroup as eg: for e in eg.exceptions: - self._logger.error("Fatal error in runner for pair %d: %s", i, e) + logging.error( + "Fatal error in runner for pair %d: %s", + env.extra_kwargs["pair_index"], + e, + ) traceback.print_exc() raise eg.exceptions[0] finally: - self._logger.debug( - "Runner for pair %d completed with %d episodes", i, episode_count + logging.debug( + "Runner for pair %d completed with %d episodes", + env.extra_kwargs["pair_index"], + episode_count, ) async def run_producers_from_stream( @@ -209,12 +197,10 @@ async def run_producers_from_stream( ), *, group_size: int, - group_key: Callable[ + group_key_fn: Callable[ [int, BaseTaskEnv, Trajectory], Hashable ] = lambda i, _, __: i, collect_mode: Optional[str] = None, - num_episodes: int = 1, - max_open_groups: Optional[int] = None, start_step_fn: Optional[Callable[[], int]] = None, ): """Dynamically runs collectors from a stream of agent-env pairs. @@ -230,7 +216,7 @@ async def run_producers_from_stream( pairs_stream: An iterable of tuples, where each tuple contains an ConversationAgentBase and a BaseTaskEnv instance. group_size: The number of trajectories to collect before forming a group. - group_key: A callable that takes `(pair_index, env, trajectory)` and + group_key_fn: A callable that takes `(pair_index, env, trajectory)` and returns a hashable group identifier. Using a callable allows for flexible grouping strategies. For example, trajectories can be grouped by task properties from the environment (`env`) or by outcomes within @@ -238,35 +224,24 @@ async def run_producers_from_stream( agent-environment pair index. collect_mode: An optional string to select the collection mode for `TrajectoryCollectEngine`. - num_episodes: The maximum number of episodes to collect for each - agent-environment pair. If None, runs indefinitely until stopped. - max_open_groups: The maximum number of groups that can be open - simultaneously in the GroupQueueManager. start_step_fn: An optional callable to get the starting step for each trajectory item. Raises: - ValueError: If `num_episodes` is not a positive integer. ValueError: If `max_concurrency` is not set. RuntimeError: If the orchestrator is already running. """ - if num_episodes <= 0: - raise ValueError( - f"num_episodes must be a positive integer, got {num_episodes}" - ) - self._logger.info( + logging.info( "Starting run_producers_from_stream with %d concurrency", self.max_concurrency, ) if not self.max_concurrency: raise ValueError("max_concurrency must be set to use start_producers.") - if self._manager: + if self._group_queue_manager: raise RuntimeError("Orchestrator is already running.") - self._manager = GroupQueueManager( - group_size=group_size, max_open_buckets=max_open_groups - ) + self._group_queue_manager = GroupQueueManager(group_size=group_size) self._stop.clear() self._tasks.clear() @@ -276,11 +251,10 @@ async def run_producers_from_stream( else: pairs_iterator = iter(pairs_stream) active_tasks: set[asyncio.Task] = set() - next_pair_index = 0 stream_exhausted = False try: - self._logger.debug( + logging.debug( "Orchestrator producer loop starting with %d concurrency", self.max_concurrency, ) @@ -294,33 +268,30 @@ async def run_producers_from_stream( and not self._stop.is_set() ): try: - self._logger.debug("Getting one pair: %d", next_pair_index) if is_async_stream: agent, env = await anext(pairs_iterator) # pytype: disable=name-error else: agent, env = next(pairs_iterator) task = asyncio.create_task( self._runner( - i=next_pair_index, agent=agent, env=env, - manager=self._manager, - group_key=group_key, - num_episodes=num_episodes, + manager=self._group_queue_manager, + group_key_fn=group_key_fn, start_step_fn=start_step_fn, collect_mode=collect_mode, ) ) active_tasks.add(task) self._tasks.append(task) - next_pair_index += 1 except (StopIteration, StopAsyncIteration): - self._logger.debug("Pairs stream exhausted.") + logging.debug("Pairs stream exhausted.") stream_exhausted = True break except Exception as e: - self._logger.error( - "Error getting next trajectory pair %d: %s", next_pair_index, e + logging.error( + "Error getting next trajectory: %s", + e, ) raise e # If no tasks are running and stream is exhausted, done. @@ -347,20 +318,20 @@ async def run_producers_from_stream( if self._tasks: await asyncio.gather(*self._tasks, return_exceptions=True) except asyncio.CancelledError: - self._logger.debug("Producer task was cancelled.") + logging.debug("Producer task was cancelled.") # The consumer's `finally` block will handle cleanup. raise except Exception as e: - self._logger.error("Producer task failed: %s", e) - if self._manager: - await self._manager.put_exception(e) + logging.error("Producer task failed: %s", e) + if self._group_queue_manager: + await self._group_queue_manager.put_exception(e) raise finally: # Shield the final cleanup step to ensure it runs even if the producer # task is being cancelled. This prevents leaving the manager in an # inconsistent state. - if self._manager: - await asyncio.shield(self._manager.prepare_clear()) + if self._group_queue_manager: + await asyncio.shield(self._group_queue_manager.prepare_clear()) async def yield_batches(self, batch_size: int): """Yields batches of trajectories from the internal queue. @@ -381,11 +352,11 @@ async def yield_batches(self, batch_size: int): RuntimeError: If `run_producers_from_stream` has not been called to start the producers. """ - if not self._manager: + if not self._group_queue_manager: raise RuntimeError("Producers have not been started.") try: while not self._stop.is_set(): - batch = await self._manager.get_batch(batch_size) + batch = await self._group_queue_manager.get_batch(batch_size) if not batch: # If batch is empty, it means producers are done and queue is empty. break @@ -394,7 +365,7 @@ async def yield_batches(self, batch_size: int): # This is the normal shutdown path when the consumer stops listening. pass except Exception as e: - self._logger.error("Error yielding batches: %s", e) + logging.error("Error yielding batches: %s", e) raise finally: # This block executes when the consumer (the 'async for' loop) stops. @@ -404,7 +375,7 @@ async def yield_batches(self, batch_size: int): # (`run_producers_from_stream`) to handle the full cleanup, as it has # the correct context to await its child tasks. self._stop.set() - self._logger.debug("Consumer stopped; signaling producers to stop.") + logging.debug("Consumer stopped; signaling producers to stop.") for t in self._tasks: if not t.done(): t.cancel() diff --git a/tunix/rl/agentic/queue_manager/group_queue_manager.py b/tunix/rl/agentic/queue_manager/group_queue_manager.py index 12fce961..c5fcb34c 100644 --- a/tunix/rl/agentic/queue_manager/group_queue_manager.py +++ b/tunix/rl/agentic/queue_manager/group_queue_manager.py @@ -15,11 +15,13 @@ """Manages queues of trajectory items, grouping them by group_id and episode_id.""" from __future__ import annotations + import asyncio import collections from collections.abc import Hashable import dataclasses -from typing import Deque, Dict, List, Optional, Tuple +from typing import Deque, Dict, List, Optional + from tunix.rl.agentic.agents import agent_types TrajectoryItem = agent_types.TrajectoryItem @@ -28,10 +30,10 @@ class GroupQueueManager: - """Manages queues of trajectory items, grouping them by group_id and episode_id. + """Manages queues of trajectory items, grouping them by group_id. This class collects `TrajectoryItem` instances into buckets based on their - `(group_id, episode_id)`. Once a bucket reaches `group_size`, it becomes a + `group_id`. Once a bucket reaches `group_size`, it becomes a "ready group" and can be retrieved in batches. It also handles managing the number of open buckets and provides mechanisms for clearing and handling exceptions. @@ -41,30 +43,23 @@ def __init__( self, *, group_size: int, - max_open_buckets: Optional[int] = None, ): self.group_size = group_size - self.max_open_buckets = max_open_buckets or 0 - self._buckets: Dict[Tuple[Hashable, int], List[TrajectoryItem]] = {} + self._buckets: Dict[Hashable, List[TrajectoryItem]] = {} self._ready_groups: Deque[List[TrajectoryItem]] = collections.deque() self._clearing = False - self._exc: Optional[BaseException] = None + self._exc: Optional[Exception] = None self._lock = asyncio.Lock() - self._capacity = asyncio.Condition(self._lock) self._have_ready = asyncio.Event() self._batch_buf: List[TrajectoryItem] = [] - async def put_exception(self, exc: BaseException): + async def put_exception(self, exc: Exception): self._exc = exc self._have_ready.set() - async with self._capacity: - self._capacity.notify_all() async def prepare_clear(self): self._clearing = True self._have_ready.set() - async with self._capacity: - self._capacity.notify_all() async def clear(self): async with self._lock: @@ -76,31 +71,23 @@ async def clear(self): self._have_ready = asyncio.Event() async def put(self, item: TrajectoryItem): - """Adds an item, grouping by `(group_id, episode_id)`. + """Adds an item, grouping by `group_id`. Items are grouped in buckets. When a bucket reaches `self.group_size`, it's - moved to `_ready_groups`. Waits if `max_open_buckets` is exceeded. + moved to `_ready_groups`. Args: item: The TrajectoryItem to add. Raises: - BaseException: If an exception has been set via `put_exception`. + Exception: If an exception has been set via `put_exception`. """ if self._clearing: return if self._exc: raise self._exc - key = (item.group_id, item.episode_id) - async with self._capacity: - new_bucket = key not in self._buckets - while ( - (not self._clearing) - and (self.max_open_buckets > 0) - and new_bucket - and (self._open_bucket_count() >= self.max_open_buckets) - ): - await self._capacity.wait() + key = item.group_id + async with self._lock: if self._clearing: return if self._exc: @@ -110,7 +97,6 @@ async def put(self, item: TrajectoryItem): if len(bucket) == self.group_size: self._ready_groups.append(bucket.copy()) del self._buckets[key] - self._capacity.notify_all() self._have_ready.set() async def _get_one_ready_group(self) -> List[TrajectoryItem]: @@ -154,6 +140,3 @@ async def get_batch(self, batch_size: int) -> List[TrajectoryItem]: out.extend(group[:room]) self._batch_buf.extend(group[room:]) return out - - def _open_bucket_count(self) -> int: - return len(self._buckets) diff --git a/tunix/rl/agentic/trajectory/trajectory_collect_engine.py b/tunix/rl/agentic/trajectory/trajectory_collect_engine.py index 7cd56c99..3031e4e9 100644 --- a/tunix/rl/agentic/trajectory/trajectory_collect_engine.py +++ b/tunix/rl/agentic/trajectory/trajectory_collect_engine.py @@ -56,15 +56,14 @@ def __init__( env: BaseTaskEnv, *, model_call: Callable[Concatenate[Dict[str, str], P], str], + model_call_kwargs: Optional[Dict[str, Any]] = None, final_reward_fn: Optional[ Callable[[Dict[str, Any], str], reward_types.RewardOutput] ] = None, - max_steps: int = 10, gamma: float = 1.0, timeout: float = 600.0, tokenizer=None, chat_parser=None, - model_call_kwargs: Optional[Dict[str, Any]] = None, ): """Initialize the trajectory collection engine. @@ -75,18 +74,17 @@ def __init__( model_call (Callable): Function that takes chat completions as first argument with optional kwargs and returns model response string. Handles the actual LLM inference. + model_call_kwargs (Optional[Dict[str, Any]]): Optional kwargs to pass to + model_call. final_reward_fn (Optional[Callable]): Optional function to compute additional reward at episode end. Takes (task, response) and returns float. Defaults to zero if not provided. - max_steps (int): Maximum number of interaction steps before forced - termination - gamma (float): Discount factor for return calculation (1.0 = no + gamma (float): Discount factor for MC reward calculation (1.0 = no discounting) timeout (float): Maximum episode duration in seconds before timeout termination tokenizer: Optional tokenizer for converting messages to token IDs chat_parser: Optional chat parser for formatting messages - model_call_kwargs: Optional kwargs to pass to model_call. """ self.agent = agent self.env = env @@ -95,7 +93,6 @@ def __init__( lambda *_: reward_types.RewardOutput(reward=0.0) ) self.model_call_kwargs = model_call_kwargs or {} - self.max_steps = max_steps self.gamma = gamma self.timeout = timeout @@ -112,16 +109,17 @@ async def collect(self, mode: str = "Conversation") -> Any: calculation, and resource cleanup. Args: - mode (str): Output format. Options: - "Trajectory": return full - Trajectory object. - "Token": return flattened tokenized dict for - training. - "Steps": return stepwise tokenized data only. - - "Conversation": return raw conversation messages (default). + mode (str): Output format. Options: + - "Trajectory": return full Trajectory object. + - "Token": return flattened tokenized dict for training. + - "Steps": return stepwise tokenized data only. + - "Conversation": return raw conversation messages (default). Returns: Trajectory | dict | list: Depending on mode. - """ + """ # fmt: skip await self._reset() - for _ in range(self.max_steps): + while True: done = await self._one_step() if done: break @@ -199,7 +197,6 @@ async def collect_multiple( final_reward_fn: Optional[ Callable[[Dict[str, Any], str], reward_types.RewardOutput] ] = None, - max_steps: int = 10, gamma: float = 1.0, timeout: float = 30.0, mode: str = "Trajectory", @@ -215,7 +212,6 @@ async def collect_multiple( environment) pairs model_call (Callable): Shared model inference function for all pairs final_reward_fn (Optional[Callable]): Shared final reward function - max_steps (int): Maximum steps per episode gamma (float): Discount factor for return calculation timeout (float): Per-episode timeout in seconds mode (str): Output format. See `collect` method for options. @@ -232,7 +228,6 @@ async def _run_one(i: int, agent: ConversationAgentBase, env: BaseTaskEnv): env, model_call=model_call, final_reward_fn=final_reward_fn, - max_steps=max_steps, gamma=gamma, timeout=timeout, ) diff --git a/tunix/rl/agentic/utils.py b/tunix/rl/agentic/utils.py index d8753c65..a6732659 100644 --- a/tunix/rl/agentic/utils.py +++ b/tunix/rl/agentic/utils.py @@ -22,6 +22,22 @@ from tunix.rl.agentic.parser.chat_template_parser import parser as chat_template_parser +def left_pad(x, length, pad): + x = np.asarray(x, dtype=np.int32) + if x.size >= length: + return x[-length:] + pad_part = np.full(length - x.size, pad, np.int32) + return np.concatenate([pad_part, x], axis=0) + + +def right_pad(x, length, pad): + x = np.asarray(x, dtype=np.int32) + if x.size >= length: + return x[:length] + pad_part = np.full(length - x.size, pad, np.int32) + return np.concatenate([x, pad_part], axis=0) + + def pad_prompt_and_completion( prompt_tokens: list[int], completion_tokens: list[int], @@ -30,21 +46,6 @@ def pad_prompt_and_completion( pad_id: int, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: """Pads prompt tokens to the left and completion tokens to the right.""" - - def left_pad(x, length, pad): - x = np.asarray(x, dtype=np.int32) - if x.size >= length: - return x[-length:] - pad_part = np.full(length - x.size, pad, np.int32) - return np.concatenate([pad_part, x], axis=0) - - def right_pad(x, length, pad): - x = np.asarray(x, dtype=np.int32) - if x.size >= length: - return x[:length] - pad_part = np.full(length - x.size, pad, np.int32) - return np.concatenate([x, pad_part], axis=0) - left_padded_prompt_tokens = left_pad(prompt_tokens, max_prompt_length, pad_id) right_padded_completion_tokens = right_pad( completion_tokens, max_generation_steps, pad_id @@ -57,7 +58,7 @@ def right_pad(x, length, pad): def get_recent_assistant_user_messages( - chat_completions_messages: list[dict[str, Any]] + chat_completions_messages: list[dict[str, Any]], ) -> tuple[Optional[dict[str, Any]], list[dict[str, Any]]]: """Extracts the most recent assistant message and environment messages (user/tool) from a chat completions list. diff --git a/tunix/rl/common.py b/tunix/rl/common.py index 563da1d7..b6e32810 100644 --- a/tunix/rl/common.py +++ b/tunix/rl/common.py @@ -397,7 +397,8 @@ def aggregate_loss( else: raise ValueError( f"Unsupported loss aggregation mode: {loss_agg_mode}. Supported modes:" - " 'token-mean', 'sequence-mean-token-mean'." + " 'token-mean', 'sequence-mean-token-mean'," + " 'sequence-mean-token-scale', 'sequence-mean-token-sum-norm'." ) return loss diff --git a/tunix/rl/experimental/agentic_grpo_learner.py b/tunix/rl/experimental/agentic_grpo_learner.py index 38dbb3e7..5addc53a 100644 --- a/tunix/rl/experimental/agentic_grpo_learner.py +++ b/tunix/rl/experimental/agentic_grpo_learner.py @@ -46,6 +46,7 @@ from tunix.rl.agentic.environments import base_environment from tunix.rl.agentic.environments import task_environment from tunix.rl.experimental import agentic_rl_learner +from tunix.utils import trajectory_logger TrainingInputT = agentic_rl_learner.TrainingInputT @@ -59,16 +60,23 @@ class GRPOConfig(agentic_rl_learner.AgenticRLConfig): """Configuration for GRPO algorithm. - Parameters: + Attributes: + algo_variant: Algorithm variant name. + advantage_estimator: Name of the advantage estimator function. + policy_loss_fn: Name of the policy loss function. + loss_agg_mode: Method for aggregating the loss. Supported values: + "token-mean", "sequence-mean-token-mean", "sequence-mean-token-scale", + "sequence-mean-token-sum-norm". num_generations: Number of samples per prompt (G in the paper). Must be > 1. num_iterations: Number of GRPO iterations per batch (μ in the paper). beta: KL penalty coefficient. epsilon: PPO-style clipping epsilon. + epsilon_high: PPO-style clipping epsilon upper bound. loss_algo: "grpo" or "gspo-token". system_prompt: System prompt for the agent. max_concurrency: Maximum number of concurrent rollout engines. - off_policy_steps: Number of off-policy steps can be accepted before a - policy update. + off_policy_steps: Number of off-policy steps can be accepted before a policy + update. """ algo_variant: str = "agentic_grpo" @@ -165,6 +173,10 @@ def __init__( ... "prompt_min_len": (min(len(p) for p in prompts), np.min), ... # ... } data_shuffle_seed: The seed used to shuffle the training data. + agent_class: The class of the agent to be used. + agent_kwargs: Keyword arguments to pass to the agent class. + env_class: The class of the environment to be used. + env_kwargs: Keyword arguments to pass to the environment class. """ # fmt: skip super().__init__( rl_cluster=rl_cluster, @@ -179,6 +191,21 @@ def __init__( env_kwargs=env_kwargs, ) + self._trajectory_logger = None + metrics_logger_options = ( + self.rl_cluster.cluster_config.training_config.metrics_logging_options + ) + metrics_log_dir = ( + metrics_logger_options.log_dir if metrics_logger_options else None + ) + + if metrics_log_dir: + self._trajectory_logger = trajectory_logger.AsyncTrajectoryLogger( + metrics_log_dir + ) + else: + logging.warning("Metrics log dir is None, skipping trajectory logging.") + # Workaround to pass loss fn with algorithm flag policy_loss_fn = function_registry.get_policy_loss_fn( self.algo_config.policy_loss_fn @@ -208,8 +235,7 @@ def __init__( def _process_results( self, - results: List[Any], - training_input: TrainingInputT, + trajectories: List[Any], mode: rl_cluster_lib.Mode = rl_cluster_lib.Mode.TRAIN, expected_step: int | None = None, ) -> List[TrainExample]: @@ -226,8 +252,7 @@ def _process_results( 8. Constructs and returns a list of `TrainExample` objects. Args: - results: A list of trajectory results for a single GRPO group. - training_input: The merged training input for the group. + trajectories: A list of trajectory results for a single GRPO group. mode: The current mode (TRAIN or EVAL). expected_step: The expected training step. @@ -236,7 +261,8 @@ def _process_results( loss function. """ logging.debug( - "Processing results to compute advantage for %d items.", len(results) + "Processing results to compute advantage for %d items.", + len(trajectories), ) # With a full group, sorting by pair_index is not necessary as they all # originate from the same initial prompt. @@ -245,9 +271,12 @@ def _process_results( # Extract completions and tokens from the group of G results. completion_texts = [] completion_tokens_list = [] + completion_masks_list = [] policy_versions_list = [] + trajectories_to_log = [] - for item in results: + for item in trajectories: + trajectories_to_log.append(item.traj) conversation = item.traj.get("conversation_text") or [] assistant_text = next( message["content"] @@ -256,37 +285,52 @@ def _process_results( ) completion_texts.append(assistant_text) completion_tokens_list.append(item.traj.get("conversation_tokens")) + completion_masks_list.append(item.traj.get("conversation_masks")) policy_version = item.traj.get("policy_version") if policy_version is None: raise ValueError("policy_version is missing from trajectory task.") policy_versions_list.append(policy_version) + # Log trajectory. + if self._trajectory_logger and trajectories_to_log: + for traj in trajectories_to_log: + self._trajectory_logger.log_item_async(traj) + # All results in a group share the same prompt. - prompt_tokens = results[0].traj.get("prompt_tokens") + prompt_tokens = trajectories[0].traj.get("prompt_tokens") # Pad all prompts and completions to consistent lengths. rollout_config = self.rl_cluster.cluster_config.rollout_config if isinstance(rollout_config, dict): rollout_config = rollout_config[mode] - max_prompt_length = rollout_config.max_prompt_length - max_tokens_to_generate = rollout_config.max_tokens_to_generate - all_padded_prompt_ids = [] - all_padded_completion_ids = [] - for completion_tokens in completion_tokens_list: + padded_prompt_ids = [] + padded_completion_ids = [] + padded_completion_masks = [] + + max_response_length = self.algo_config.max_response_length + for completion_tokens, completion_mask in zip( + completion_tokens_list, completion_masks_list + ): padded_prompt, padded_completion, _ = ( agentic_utils.pad_prompt_and_completion( prompt_tokens, completion_tokens, - max_prompt_length, - max_tokens_to_generate, + rollout_config.max_prompt_length, + max_response_length, pad_value, ) ) - all_padded_prompt_ids.append(padded_prompt) - all_padded_completion_ids.append(padded_completion) + padded_prompt_ids.append(padded_prompt) + padded_completion_ids.append(padded_completion[:max_response_length]) + padded_completion_masks.append( + agentic_utils.right_pad(completion_mask, max_response_length, 0)[ + :max_response_length + ] + ) - prompt_ids = jnp.asarray(all_padded_prompt_ids) - completion_ids = jnp.asarray(all_padded_completion_ids) + prompt_ids = jnp.asarray(padded_prompt_ids) + completion_ids = jnp.asarray(padded_completion_ids) + completion_mask = jnp.asarray(padded_completion_masks) logging.debug( "Token shapes: prompt_ids=%s, completion_ids=%s", prompt_ids.shape, @@ -295,11 +339,6 @@ def _process_results( # Masks prompt_mask = prompt_ids != pad_value - completion_padding_mask = jnp.not_equal(completion_ids, pad_value) - completion_mask = common.make_completion_mask( - completion_ids, eos_tok=eos_value - ) - completion_mask = completion_mask * completion_padding_mask if self.algo_config.beta != 0.0: ref_per_token_logps = self.rl_cluster.get_ref_per_token_logps( prompt_tokens=prompt_ids, @@ -324,15 +363,20 @@ def _process_results( # Prepare arguments for reward computation by forwarding all training inputs # except for prompts, which is passed explicitly. + original_input = trajectories[0].traj["original_input"] + original_inputs = rl_utils.merge_micro_batches( + [original_input] * self.algo_config.num_generations + ) + reward_kwargs = { - key: value for key, value in training_input.items() if key != "prompts" + key: value for key, value in original_inputs.items() if key != "prompts" } # TODO: b/456528861 - Refactor reward computation to happen within the # environment during rollout, rather than as a post-processing step. This # would align with the standard agentic RL pattern and remove the need for # `dummy_reward`. rewards = self._compute_rewards( - prompts=training_input["prompts"], + prompts=original_inputs["prompts"], completions=completion_texts, mode=mode, **reward_kwargs, @@ -370,13 +414,13 @@ def _process_results( ) for metric_fn in self.metric_fns: user_defined_metric = metric_fn( - prompts=training_input["prompts"], + prompts=original_inputs["prompts"], completions=completion_texts, advantages=advantages, rewards=rewards, **{ key: value - for key, value in training_input.items() + for key, value in original_inputs.items() if key != "prompts" }, ) diff --git a/tunix/rl/experimental/agentic_rl_learner.py b/tunix/rl/experimental/agentic_rl_learner.py index 2394c7f8..c669b0bf 100644 --- a/tunix/rl/experimental/agentic_rl_learner.py +++ b/tunix/rl/experimental/agentic_rl_learner.py @@ -18,24 +18,25 @@ import abc import asyncio -from concurrent import futures +from concurrent.futures import ThreadPoolExecutor import contextlib +import copy import dataclasses import itertools import queue import threading -from typing import Any, AsyncIterator, Callable, Coroutine, Dict, Generic, Iterable, Iterator, List, Sequence, Type, TypeVar +from typing import Any, AsyncIterator, Callable, Dict, Generic, Iterable, Iterator, List, Sequence, Type, TypeVar from absl import logging import flax import jax -from tunix.rl import reward_manager # pylint: disable=unused-import from jax import typing import jax.numpy as jnp import numpy as np from tunix.rl import algorithm_config as algo_config_lib from tunix.rl import common from tunix.rl import function_registry +from tunix.rl import reward_manager # pylint: disable=unused-import from tunix.rl import rl_cluster as rl_cluster_lib from tunix.rl import utils as rl_utils from tunix.rl.agentic import utils as agentic_utils @@ -66,7 +67,9 @@ class AgenticRLConfig(algo_config_lib.AlgorithmConfig): Parameters: system_prompt: System prompt for the agent. - max_concurrency: Maximum number of concurrent rollout engines. + max_response_length: Maximum number of tokens for each episode. + max_concurrency: Maximum number of concurrent requests to the rollout + engines. off_policy_steps: Number of off-policy steps can be accepted before a policy update. num_generations: Number of samples per prompt. @@ -75,7 +78,10 @@ class AgenticRLConfig(algo_config_lib.AlgorithmConfig): """ system_prompt: str = "" - max_concurrency: int = 16 + # TODO(tsbao): we need to update the scripts that uses max_tokens_to_generate + # once this new agentic_rl_learner is used. + max_response_length: int = 1024 + max_concurrency: int = 32 off_policy_steps: int = 0 num_generations: int = 1 num_iterations: int = 1 @@ -141,6 +147,7 @@ def __init__( """ self.rl_cluster = rl_cluster self.algo_config = algo_config + self._patch_rollout_config() reward_manager_fn = function_registry.get_reward_manager( algo_config.reward_manager @@ -174,7 +181,7 @@ def __init__( self.rl_cluster.actor_trainer.restored_global_step() ) # Current iter steps for micro-batch based training. - self._iter_steps = 0 + self._iter_steps = self.rl_cluster.actor_trainer.iter_steps self._eval_iter_steps = 0 # Sync weights if the actor model and rollout model are not sharing weights. @@ -194,7 +201,6 @@ def __init__( rl_cluster_lib.Role.ROLLOUT ] ) - self._last_iter_step = self.rl_cluster.actor_trainer.iter_steps self._rollout_micro_batch_size = ( self._training_config.rollout_micro_batch_size @@ -214,6 +220,9 @@ def __init__( def run_loop_forever(): loop = agentic_utils.get_or_create_loop() + loop.set_default_executor( + ThreadPoolExecutor(max_workers=algo_config.max_concurrency + 1) + ) loop_queue.put(loop) loop.run_forever() @@ -221,6 +230,13 @@ def run_loop_forever(): loop_thread.start() self.loop = loop_queue.get() + def _patch_rollout_config(self): + rollout_config = self.rl_cluster.cluster_config.rollout_config + if not isinstance(rollout_config, dict): + rollout_config = {"train": rollout_config} + for config in rollout_config.values(): + config.max_tokens_to_generate = self.algo_config.max_response_length + def _compute_rewards( self, prompts: List[str], @@ -316,7 +332,7 @@ def get_buffer_len(buf: dict[str, list[Any]]) -> int: yield micro_batch def _create_agent_env_pair( - self, single_example: TrainingInputT, group_id: int + self, single_example: TrainingInputT, group_id: int, pair_index: int ) -> tuple[base_agent.ConversationAgentBase, base_environment.BaseTaskEnv]: """Constructs an (agent, environment) pair for a single input sample. @@ -324,8 +340,9 @@ def _create_agent_env_pair( Args: single_example: A training input containing a single prompt. - group_id: An identifier to group generations from the same original + group_id: An identifier for group generations from the same original prompt. + pair_index: The index of the pair within the group. Returns: A tuple of agent and environment. @@ -333,8 +350,12 @@ def _create_agent_env_pair( agent = self.agent_class( **{"system_prompt": self.algo_config.system_prompt, **self.agent_kwargs} ) # if agent_kwargs contains "system_prompt", it will be honored. + + assert "group_id" not in self.env_kwargs + assert "pair_index" not in self.env_kwargs env = self.env_class( - single_example, **{"group_id": group_id, **self.env_kwargs} + single_example, + **{"group_id": group_id, "pair_index": pair_index, **self.env_kwargs}, ) return agent, env @@ -394,33 +415,54 @@ async def _orchestrator_producer( collect_mode: The mode for trajectory collection (e.g., "Token"). Yields: - A tuple where the first element is a list of trajectory results for a - group, and the second is a list containing the original `TrainingInputT` - for that group. + A list of trajectories for a group. """ is_async_iterator = hasattr(prompt_iterator, "__aiter__") async def pairs_stream_generator(): """Yield (agent, env) pairs with unique group_id per original prompt.""" - i = 0 + # TODO (tsbao): fix the group id when we can resume from mid global step + # with mini-batch. + group_id = self.rl_cluster.global_steps * self._full_batch_size if is_async_iterator: async for single_example in prompt_iterator: - agent, env = self._create_agent_env_pair(single_example, group_id=i) - yield agent, env - i += 1 + # Create agent-env pairs in parallel for a group to handle potential + # cold start latency on env creation. + agent_env_pairs = await asyncio.gather(*[ + self.loop.run_in_executor( + None, + self._create_agent_env_pair, + copy.deepcopy(single_example), + group_id, + pair_index, + ) + for pair_index in range(num_generations) + ]) + for agent, env in agent_env_pairs: + yield agent, env + group_id += 1 else: for single_example in prompt_iterator: - agent, env = self._create_agent_env_pair(single_example, group_id=i) - yield agent, env - i += 1 + agent_env_pairs = await asyncio.gather(*[ + self.loop.run_in_executor( + None, + self._create_agent_env_pair, + copy.deepcopy(single_example), + group_id, + pair_index, + ) + for pair_index in range(num_generations) + ]) + for agent, env in agent_env_pairs: + yield agent, env + group_id += 1 # Start producers in the background. producer_task = asyncio.create_task( orchestrator.run_producers_from_stream( pairs_stream=pairs_stream_generator(), group_size=self.algo_config.num_generations, - group_key=lambda i, env, traj: env.extra_kwargs["group_id"], - num_episodes=num_generations, + group_key_fn=lambda i, env, traj: env.extra_kwargs["group_id"], collect_mode=collect_mode, ) ) @@ -437,8 +479,7 @@ async def pairs_stream_generator(): async for group in stream: if group: # Retrieve the original input embedded in the task. - original_input = group[0].traj["original_input"] - yield group, [original_input] + yield group except (GeneratorExit, asyncio.CancelledError): # This is the normal shutdown path for a generator. return @@ -457,14 +498,12 @@ async def await_cancellation(): def _batch_to_train_example( self, batch_results: list[Any], - cached_inputs_for_window: list[TrainingInputT], mode: rl_cluster_lib.Mode, ) -> List[TrainExample]: """Converts a group of trajectories into a list of `TrainExample`s. Args: - batch_results: A list of trajectory results from the orchestrator. - cached_inputs_for_window: The original input data for this group. + batch_results: A list of trajectories from the same generation group. mode: The current mode (TRAIN or EVAL). Returns: @@ -473,28 +512,14 @@ def _batch_to_train_example( # Create a merged training_input where each field from the original input # is repeated G times to align with the G completions. num_generations = self.algo_config.num_generations - micro_batches = [cached_inputs_for_window[0]] * num_generations - training_input = rl_utils.merge_micro_batches(micro_batches) - - prompt_index = batch_results[0].pair_index + prompt_index = batch_results[0].pair_index // num_generations if mode == rl_cluster_lib.Mode.TRAIN and self._full_batch_size: expected_step = prompt_index // self._full_batch_size else: expected_step = self.rl_cluster.global_steps - trajectory_ids = self._compute_trajectory_ids(training_input, prompt_index) - assert "trajectory_ids" not in training_input - training_input["trajectory_ids"] = trajectory_ids - for t_id in trajectory_ids: - self.rl_cluster.buffer_metrics_async( - { - "trajectory_ids": (t_id, None), - }, - mode=mode, - step=expected_step, - ) + return self._process_results( - results=batch_results, - training_input=training_input, + trajectories=batch_results, mode=mode, expected_step=expected_step, ) @@ -502,8 +527,7 @@ def _batch_to_train_example( @abc.abstractmethod def _process_results( self, - results: List[Any], - training_input: TrainingInputT, + trajectories: List[Any], mode: rl_cluster_lib.Mode = rl_cluster_lib.Mode.TRAIN, expected_step: int | None = None, ) -> List[TrainExample]: @@ -520,30 +544,6 @@ def _generate_and_compute_advantage( "_generate_and_compute_advantage is not used in AgenticRLLearner" ) - def _compute_trajectory_ids( - self, example: TrainingInputT, prompt_index: int - ) -> List[str]: - """Computes the trajectory ID for each prompt in the batch.""" - batch_size = len(example["prompts"]) // self.algo_config.num_generations - if batch_size != 1: - raise ValueError( - "_compute_trajectory_ids expects inputs for a single prompt group," - f" but got batch_size={batch_size}" - ) - row_offset = prompt_index - row_offsets = np.repeat( - np.arange(row_offset, row_offset + batch_size), - self.algo_config.num_generations, - axis=0, - ) - group_offsets = np.tile( - np.arange(self.algo_config.num_generations), - batch_size, - ) - return [ - f"{r_off}_{g_off}" for r_off, g_off in zip(row_offsets, group_offsets) - ] - def _num_iterations(self) -> int: """Returns the number of iterations per batch.""" return self.algo_config.num_iterations @@ -569,7 +569,7 @@ async def _iterate_micro_batches(): prompt_iterator = _iterate_micro_batches() try: - async for batch, cached_inputs in self._orchestrator_producer( + async for batch in self._orchestrator_producer( orchestrator=orchestrator, prompt_iterator=prompt_iterator, num_generations=self.algo_config.num_generations, @@ -578,7 +578,6 @@ async def _iterate_micro_batches(): try: train_examples = self._batch_to_train_example( batch_results=batch, - cached_inputs_for_window=cached_inputs, mode=rl_cluster_lib.Mode.TRAIN, ) iterations = self.algo_config.num_iterations @@ -618,6 +617,22 @@ def train( """Main training loop for the AgenticRLLearner.""" full_batch_iterator = iter(train_dataset) + if self.rl_cluster.global_steps > 0: + logging.info( + "Skipping %d batches from train_dataset to fast-forward to step %d", + self.rl_cluster.global_steps, + self.rl_cluster.global_steps, + ) + # TODO(b/483779605): Current implementation of fast-forwarding does not + # take into account the mini-batch size. Follow-up CL will address this. + for _ in range(self.rl_cluster.global_steps): + try: + next(full_batch_iterator) + except StopIteration: + logging.warning("Train dataset exhausted while skipping batches.") + self.rl_cluster.close() + return + try: first_item = next(full_batch_iterator) except StopIteration: @@ -632,6 +647,8 @@ def train( train_micro_batch_size = ( self._training_config.train_micro_batch_size or mini_batch_size ) + # Rollout and compute_logps micro batch sizes have to be 1 since we only + # process inidividual prompts. self._rollout_micro_batch_size = 1 self._compute_logps_micro_batch_size = 1 for v, n in [ @@ -704,29 +721,10 @@ def train( self._iter_steps += 1 # Filter out examples that are too old (off-policy). - filtered_train_micro_batch = [] - for train_example in train_micro_batch: - if train_example.policy_version is not None and ( - train_example.policy_version[0] == -1 - or ( - self.policy_version - train_example.policy_version[0] - <= self.algo_config.off_policy_steps - ) - ): - filtered_train_micro_batch.append(train_example) + filtered_train_micro_batch = self._filter_outdated_offpolicy_examples( + train_micro_batch + ) if not filtered_train_micro_batch: - logging.warning( - "Skipping microbatch: all %d examples are too old." - " Current policy version: %d, data versions: %s," - " off_policy_steps: %d", - len(train_micro_batch), - self.policy_version, - str([ - train_example.policy_version[0] - for train_example in train_micro_batch - ]), - self.algo_config.off_policy_steps, - ) continue train_micro_batch = filtered_train_micro_batch @@ -747,17 +745,16 @@ def train( async def _eval_runner_async(current_eval_orchestrator): eval_examples = [] - async for batch, cached_inputs in self._orchestrator_producer( + async for batch in self._orchestrator_producer( current_eval_orchestrator, all_eval_prompts, num_generations=self._num_generations(), ): - train_examples = self._batch_to_train_example( + eval_example = self._batch_to_train_example( batch, - cached_inputs, rl_cluster_lib.Mode.EVAL, ) - eval_examples.extend(train_examples) + eval_examples.extend(eval_example) return eval_examples eval_future = asyncio.run_coroutine_threadsafe( @@ -837,3 +834,33 @@ def _put_prompts_to_queue( prompt_queue.put(None) else: prompt_queue.put(batch) + + def _filter_outdated_offpolicy_examples( + self, + train_micro_batch: List[TrainExample], + ) -> List[TrainExample]: + """Filters out outdated off-policy examples.""" + filtered_train_micro_batch = [] + for train_example in train_micro_batch: + if train_example.policy_version is not None and ( + train_example.policy_version[0] == -1 + or ( + self.policy_version - train_example.policy_version[0] + <= self.algo_config.off_policy_steps + ) + ): + filtered_train_micro_batch.append(train_example) + if not filtered_train_micro_batch: + logging.warning( + "Skipping microbatch: all %d examples are too old." + " Current policy version: %d, data versions: %s," + " off_policy_steps: %d", + len(train_micro_batch), + self.policy_version, + str([ + train_example.policy_version[0] + for train_example in train_micro_batch + ]), + self.algo_config.off_policy_steps, + ) + return filtered_train_micro_batch diff --git a/tunix/rl/grpo/grpo_learner.py b/tunix/rl/grpo/grpo_learner.py index 2333d6df..defa0fd1 100644 --- a/tunix/rl/grpo/grpo_learner.py +++ b/tunix/rl/grpo/grpo_learner.py @@ -23,6 +23,7 @@ import jax import jax.numpy as jnp import numpy as np +from tunix.generate import utils from tunix.rl import algorithm_config as algo_config_lib from tunix.rl import common from tunix.rl import function_registry @@ -114,7 +115,6 @@ class GRPOLearner(rl_learner.RLLearner[TGrpoConfig]): generating multiple responses for a given prompt, evaluating these responses using a reward model, and then calculating a relative advantage based on the group's performance to update the policy. - """ def __init__( @@ -204,6 +204,10 @@ def _generate_and_compute_advantage( prompt IDs, completion IDs, masks, advantages, and per-token log probabilities from the reference and policy models. """ + rollout_config = self.rl_cluster.cluster_config.rollout_config + if isinstance(rollout_config, dict): + rollout_config = rollout_config[mode] + training_input["prompts"] = list(training_input["prompts"]) pad_value = self.rl_cluster.rollout.pad_id() eos_value = self.rl_cluster.rollout.eos_id() @@ -214,21 +218,23 @@ def _generate_and_compute_advantage( self._rollout_micro_batch_size * self.algo_config.num_generations ), ) - completion_ids = rollout_output.tokens + padded_completion_ids = np.array([ + utils.pad_to_length( + completion_ids, + target_length=rollout_config.max_tokens_to_generate, + pad_value=pad_value, + left=False, + ) + for completion_ids in rollout_output.tokens + ]) prompt_ids = jnp.array(rollout_output.left_padded_prompt_tokens) - completion_text = rollout_output.text # Assemble masks prompt_mask = prompt_ids != pad_value - completion_padding_mask = np.not_equal(completion_ids, pad_value) - completion_mask = common.np_make_completion_mask( - completion_ids, eos_tok=eos_value - ) - # Apply the padding mask to the completion mask. - completion_mask = completion_mask * completion_padding_mask + completion_mask = np.not_equal(padded_completion_ids, pad_value) # Convert completion_ids and completion_mask to jax arrays - jax_completion_ids = jnp.array(completion_ids) + jax_completion_ids = jnp.array(padded_completion_ids) jax_completion_mask = jnp.array(completion_mask) if self.algo_config.beta != 0.0: @@ -269,7 +275,7 @@ def _generate_and_compute_advantage( # Compute rewards and advantages rewards = self._compute_rewards( prompts=training_input["prompts"], - completions=completion_text, + completions=rollout_output.text, mode=mode, **{k: v for k, v in training_input.items() if k != "prompts"}, ) @@ -302,7 +308,7 @@ def _generate_and_compute_advantage( for m_fn in self.metric_fns: user_defined_metric = m_fn( prompts=training_input["prompts"], - completions=completion_text, + completions=rollout_output.text, advances=advantages, rewards=rewards, **{k: v for k, v in training_input.items() if k != "prompts"}, diff --git a/tunix/rl/ppo/ppo_learner.py b/tunix/rl/ppo/ppo_learner.py index 168f8d99..b869554f 100644 --- a/tunix/rl/ppo/ppo_learner.py +++ b/tunix/rl/ppo/ppo_learner.py @@ -17,13 +17,14 @@ from __future__ import annotations import dataclasses -from typing import Generic, Iterable, List, Sequence +from typing import Iterable, List, Sequence import flax from flax import nnx import jax import jax.numpy as jnp import numpy as np +from tunix.generate import utils from tunix.rl import algorithm_config as algo_config_lib from tunix.rl import common from tunix.rl import function_registry @@ -243,6 +244,9 @@ def _generate_and_compute_advantage( Returns: A `TrainExample` instance containing the processed input data for PPO. """ + rollout_config = self.rl_cluster.cluster_config.rollout_config + if isinstance(rollout_config, dict): + rollout_config = rollout_config[mode] pad_value = self.rl_cluster.rollout.pad_id() eos_value = self.rl_cluster.rollout.eos_id() @@ -252,22 +256,28 @@ def _generate_and_compute_advantage( # ===== Generation ====== # Generate. We use `model`, i.e., the policy model for generating the # "experiences". - completion_output = self.rl_cluster.generate( + rollout_output = self.rl_cluster.generate( prompts=training_input["prompts"], micro_batch_size=self._rollout_micro_batch_size, ) - completion_ids = completion_output.tokens - prompt_ids = jnp.array(completion_output.left_padded_prompt_tokens) - - batch_size = completion_ids.shape[0] - logits_to_keep = completion_ids.shape[1] + padded_completion_ids = np.array([ + utils.pad_to_length( + completion_ids, + target_length=rollout_config.max_tokens_to_generate, + pad_value=pad_value, + left=False, + ) + for completion_ids in rollout_output.tokens + ]) + prompt_ids = jnp.array(rollout_output.left_padded_prompt_tokens) + + batch_size = padded_completion_ids.shape[0] + logits_to_keep = padded_completion_ids.shape[1] prompt_mask = (prompt_ids != pad_value).astype("int32") - completion_mask = common.np_make_completion_mask( - completion_ids, eos_tok=eos_value - ) + completion_mask = np.not_equal(padded_completion_ids, pad_value) # Convert completion_ids and completion_mask to jax arrays - jax_completion_ids = jnp.array(completion_ids) + jax_completion_ids = jnp.array(padded_completion_ids) jax_completion_mask = jnp.array(completion_mask) eos_idx = jnp.max( @@ -325,7 +335,7 @@ def _generate_and_compute_advantage( else: last_token_scores = self._compute_rewards( prompts=training_input["prompts"], - completions=completion_output.text, + completions=rollout_output.text, mode=mode, **{k: v for k, v in training_input.items() if k != "prompts"}, ) diff --git a/tunix/rl/rl_cluster.py b/tunix/rl/rl_cluster.py index dc0ca7cf..dc13946c 100644 --- a/tunix/rl/rl_cluster.py +++ b/tunix/rl/rl_cluster.py @@ -863,14 +863,14 @@ def generate( itertools.chain.from_iterable(out.logprobs for out in outputs) ) - logits = None - if isinstance(outputs[0].logits, jnp.ndarray): - logits = jnp.concatenate([out.logits for out in outputs], axis=0) - return base_rollout.RolloutOutput( text=texts, - logits=logits, - tokens=np.concatenate([out.tokens for out in outputs], axis=0), + logits=list( + itertools.chain.from_iterable(out.logits for out in outputs) + ), + tokens=list( + itertools.chain.from_iterable(out.tokens for out in outputs) + ), left_padded_prompt_tokens=np.concatenate( [out.left_padded_prompt_tokens for out in outputs], axis=0 ), diff --git a/tunix/rl/rollout/base_rollout.py b/tunix/rl/rollout/base_rollout.py index fb740a79..03b265fb 100644 --- a/tunix/rl/rollout/base_rollout.py +++ b/tunix/rl/rollout/base_rollout.py @@ -45,15 +45,15 @@ class RolloutOutput: # Generated samples from the model. text: list[str] - # Per-step logits used during sampling. + # Unpadded per-step logits used during sampling. # TODO(tsbao): consider enforcing this to be np.ndarray as well, # but let's solve it as part of the IS effort. - logits: jax.Array + logits: list[jax.Array] - # Tokens corresponding to the generated samples. + # Unpadded tokens corresponding to the generated samples. # Since tokens need to be transfered to RAM for decoding, we use numpy array # here. - tokens: np.ndarray + tokens: list[np.ndarray] # Left padded prompt tokens. # TODO(tsbao): Reconcile with vLLM output and see if we should remove this @@ -157,6 +157,9 @@ class RolloutConfig: # Maximum number of concurrent sequences allowed to be processed in vLLM. rollout_vllm_max_num_seqs: Optional[int] = None + # Additional keyword arguments forwarded directly to the vLLM sampler/engine. + rollout_vllm_kwargs: dict[str, Any] = dataclasses.field(default_factory=dict) + # SG-Lang JAX specific rollout configs. # Model version for SG-Lang JAX rollout engine. @@ -204,13 +207,22 @@ class RolloutConfig: rollout_sglang_jax_chunked_prefill_size: Optional[int] = -1 # The number of tokens in a page - rollout_sglang_jax_page_size: int = 64 + rollout_sglang_jax_page_size: int = 128 # The format of the model weights to load. rollout_sglang_jax_load_format: str = "auto" + # The maximum number of running requests to accumulate batch rollout_sglang_jax_max_running_requests: Optional[int] = None + # The log level of sglang_jax + rollout_sglang_jax_log_level: Optional[str] = "info" + + # Additional keyword arguments forwarded directly to the SG-Lang JAX sampler/engine. + rollout_sglang_jax_kwargs: dict[str, Any] = dataclasses.field( + default_factory=dict + ) + class BaseRollout(ABC): """Base RolloutWorker.""" diff --git a/tunix/rl/rollout/sglang_jax_rollout.py b/tunix/rl/rollout/sglang_jax_rollout.py index e96cd468..cc20d847 100644 --- a/tunix/rl/rollout/sglang_jax_rollout.py +++ b/tunix/rl/rollout/sglang_jax_rollout.py @@ -63,7 +63,9 @@ def __init__( page_size=rollout_config.rollout_sglang_jax_page_size, load_format=rollout_config.rollout_sglang_jax_load_format, max_running_requests=rollout_config.rollout_sglang_jax_max_running_requests, + log_level=rollout_config.rollout_sglang_jax_log_level, ), + **rollout_config.rollout_sglang_jax_kwargs, ) state = nnx.state(model) self._sampler.load_checkpoint(state) @@ -85,6 +87,7 @@ def generate( seed=rollout_config.seed, echo=False, pad_output=True, + **kwargs, ) return base_rollout.RolloutOutput( diff --git a/tunix/rl/rollout/vanilla_rollout.py b/tunix/rl/rollout/vanilla_rollout.py index c79a12a3..dd8efcd1 100644 --- a/tunix/rl/rollout/vanilla_rollout.py +++ b/tunix/rl/rollout/vanilla_rollout.py @@ -60,7 +60,7 @@ def generate( top_p=rollout_config.top_p, top_k=rollout_config.top_k, seed=rollout_config.seed, - pad_output=True, + pad_output=False, eos_tokens=rollout_config.eos_tokens, ) return base_rollout.RolloutOutput( diff --git a/tunix/rl/rollout/vllm_rollout.py b/tunix/rl/rollout/vllm_rollout.py index 16af1225..65d36115 100644 --- a/tunix/rl/rollout/vllm_rollout.py +++ b/tunix/rl/rollout/vllm_rollout.py @@ -43,24 +43,31 @@ def __init__( self._sampler = vllm_sampler.VllmSampler( tokenizer=tokenizer, config=vllm_sampler.VllmConfig( - max_model_len=cache_config_or_size, - mesh=mesh, - model_version=rollout_config.rollout_vllm_model_version, - hbm_utilization=rollout_config.rollout_vllm_hbm_utilization, + server_mode=rollout_config.rollout_vllm_server_mode, + mapping_config=mapping_config, init_with_random_weights=rollout_config.rollout_vllm_init_with_random_weights, tpu_backend_type=rollout_config.rollout_vllm_tpu_backend_type, - mapping_config=mapping_config, - lora_config=rollout_config.rollout_vllm_lora_config, - swap_space=rollout_config.rollout_vllm_swap_space_size_gb, - server_mode=rollout_config.rollout_vllm_server_mode, - async_scheduling=rollout_config.rollout_vllm_async_scheduling, - tensor_parallel_size=rollout_config.tensor_parallel_size, - data_parallel_size=rollout_config.data_parallel_size, - enable_dp_attention=rollout_config.rollout_vllm_enable_dp_attention, - max_num_batched_tokens=rollout_config.rollout_vllm_max_num_batched_tokens, - max_num_seqs=rollout_config.rollout_vllm_max_num_seqs, - hf_config_path=rollout_config.rollout_vllm_hf_config_path, additional_config=rollout_config.rollout_vllm_additional_config, + enable_dp_attention=rollout_config.rollout_vllm_enable_dp_attention, + hbm_utilization=rollout_config.rollout_vllm_hbm_utilization, + lora_config=rollout_config.rollout_vllm_lora_config, + mesh=mesh, + engine_kwargs={ + "model": rollout_config.rollout_vllm_model_version, + "max_model_len": cache_config_or_size, + "swap_space": rollout_config.rollout_vllm_swap_space_size_gb, + "async_scheduling": ( + rollout_config.rollout_vllm_async_scheduling + ), + "tensor_parallel_size": rollout_config.tensor_parallel_size, + "data_parallel_size": rollout_config.data_parallel_size, + "max_num_batched_tokens": ( + rollout_config.rollout_vllm_max_num_batched_tokens + ), + "max_num_seqs": rollout_config.rollout_vllm_max_num_seqs, + "hf_config_path": rollout_config.rollout_vllm_hf_config_path, + **rollout_config.rollout_vllm_kwargs, + }, ), ) state = nnx.state(model) @@ -87,6 +94,7 @@ def generate( seed=rollout_config.seed, echo=False, pad_output=True, + **kwargs, ) return base_rollout.RolloutOutput( diff --git a/tunix/rl/utils.py b/tunix/rl/utils.py index f2e6fa1c..6b54c62b 100644 --- a/tunix/rl/utils.py +++ b/tunix/rl/utils.py @@ -178,7 +178,8 @@ def merge_micro_batches(batches: List[dict[str, Any]]) -> dict[str, Any]: merged[key] = list(chain.from_iterable(all_values)) else: merged[key] = tree_util.tree_map( - lambda *xs: np.concatenate(xs), *all_values + lambda *xs: np.concatenate([np.atleast_1d(x) for x in xs]), + *all_values, ) return merged diff --git a/tunix/sft/checkpoint_manager.py b/tunix/sft/checkpoint_manager.py index 87b851f7..2cca1eb3 100644 --- a/tunix/sft/checkpoint_manager.py +++ b/tunix/sft/checkpoint_manager.py @@ -175,19 +175,36 @@ def maybe_restore( else: abstract_params = nnx.state(model) - def map_to_pspec(data): - return ocp.type_handlers.ArrayRestoreArgs(sharding=data.sharding) - model_cp_args = ocp.args.PyTreeRestore( item=abstract_params, - restore_args=jax.tree_util.tree_map(map_to_pspec, abstract_params), + restore_args=ocp.checkpoint_utils.construct_restore_args( + target=abstract_params + ), ) + def fix_sharding(state): + # Scalar values in optimizer states like step and count is initialized as + # SingleDeviceSharding, which will fail if optimizer is sharded. To fix + # it, we will replicate the scalar values. + shardings = jax.tree_util.tree_map(lambda x: x.sharding, state) + try: + named_sharding = next( + s + for s in jax.tree_util.tree_leaves(shardings) + if isinstance(s, jax.sharding.NamedSharding) + ) + return nnx.get_named_sharding(optimizer_state, named_sharding.mesh) + except StopIteration: + return shardings + if optimizer is not None and 'optimizer_state' in metadata.item_metadata: optimizer_state = nnx.state(optimizer, nnx.optimizer.OptState) + fixed_sharding = fix_sharding(optimizer_state) optimizer_cp_args = ocp.args.PyTreeRestore( item=optimizer_state, - restore_args=jax.tree_util.tree_map(map_to_pspec, optimizer_state), + restore_args=ocp.checkpoint_utils.construct_restore_args( + target=optimizer_state, sharding_tree=fixed_sharding + ), ) ckpt = self._checkpoint_manager.restore( step, diff --git a/tunix/sft/metrics_logger.py b/tunix/sft/metrics_logger.py index ac8d234a..1516beaa 100644 --- a/tunix/sft/metrics_logger.py +++ b/tunix/sft/metrics_logger.py @@ -3,9 +3,9 @@ import collections import dataclasses import enum -import logging from typing import Callable +from absl import logging import jax from metrax import logging as metrax_logging import numpy as np diff --git a/tunix/sft/peft_trainer.py b/tunix/sft/peft_trainer.py index 7aaf867a..97b8a248 100644 --- a/tunix/sft/peft_trainer.py +++ b/tunix/sft/peft_trainer.py @@ -180,6 +180,7 @@ class PeftTrainer: input. checkpoint_manager: The checkpoint manager to use. metrics_logger: The metrics logger to use. + metrics_prefix: The prefix for metric names for logging. is_managed_externally: Whether the trainer is managed externally. training_hooks: The training hooks to use. data_hooks: The data hooks to use. @@ -204,6 +205,7 @@ def __init__( self.optimizer = nnx.Optimizer(self.model, optimizer, wrt=nnx.LoRAParam) else: self.optimizer = nnx.Optimizer(self.model, optimizer, wrt=nnx.Param) + self.loss_fn = _default_loss_fn self.eval_loss_fn = _default_loss_fn self.gen_model_input_fn = lambda x: x @@ -577,7 +579,7 @@ def train( logging.log_if( logging.INFO, f"Compiled train_step cache size: {cache_size}", - lambda: cache_size not in self._jit_cache, + condition=cache_size not in self._jit_cache, ) self._jit_cache.add(cache_size) diff --git a/tunix/tests/test_common.py b/tunix/tests/test_common.py index f6662d5b..9d06ef9e 100644 --- a/tunix/tests/test_common.py +++ b/tunix/tests/test_common.py @@ -28,12 +28,13 @@ import jax.numpy as jnp import numpy as np import qwix -import sentencepiece as spm import tenacity from tunix.rl import reshard from tunix.utils import compat from tunix.utils import env_utils +import sentencepiece as spm + env_utils.setup_sharding_environment() @@ -86,12 +87,16 @@ def __init__(self, rngs: nnx.Rngs): out_features=32, rngs=rngs, kernel_init=nnx.with_partitioning(kernel_init_fn, ('fsdp', 'tp')), + bias_init=nnx.with_partitioning(nnx.initializers.zeros_init(), ('tp',)), ) self.w2 = nnx.Linear( in_features=32, out_features=16, rngs=rngs, kernel_init=nnx.with_partitioning(kernel_init_fn, ('tp', 'fsdp')), + bias_init=nnx.with_partitioning( + nnx.initializers.zeros_init(), ('fsdp',) + ), ) def __call__(self, x): @@ -187,33 +192,35 @@ def get_lora_model( class MockVocab(spm.SentencePieceProcessor): """Mock vocabulary for testing.""" - def __init__(self): + DEFAULT_MAPPING = { + '': 0, + '': 1, + '': 2, + 'input': 3, + 'string': 4, + 'hello': 5, + 'world': 6, + 'Hello': 7, + 'there': 8, + '!': 9, + 'My': 10, + 'name': 11, + 'is': 12, + 'Morgane': 13, + 'Tunix': 14, + 'Parallax': 15, + 'PT': 16, + 'library': 17, + 'distributed': 18, + 'training': 19, + 'optimizer': 20, + 'quantization': 21, + } + + def __init__(self, mapping_text_to_id: dict[str, int] | None = None): super().__init__() self._start_id = 3 - self._mapping_text_to_id = { - '': 0, - '': 1, - '': 2, - 'input': 3, - 'string': 4, - 'hello': 5, - 'world': 6, - 'Hello': 7, - 'there': 8, - '!': 9, - 'My': 10, - 'name': 11, - 'is': 12, - 'Morgane': 13, - 'Tunix': 14, - 'Parallax': 15, - 'PT': 16, - 'library': 17, - 'distributed': 18, - 'training': 19, - 'optimizer': 20, - 'quantization': 21, - } + self._mapping_text_to_id = mapping_text_to_id or self.DEFAULT_MAPPING self._vocab_size = len(self._mapping_text_to_id) def pad_id(self) -> int: @@ -234,11 +241,12 @@ def DecodeIds(self, ids: Iterable[int]) -> str: # pylint: disable=invalid-name def EncodeAsIds(self, text: str, **kwargs) -> list[int]: # pylint: disable=invalid-name words = text.split(' ') - return [ + res = [ self._mapping_text_to_id[word] for word in words if word in self._mapping_text_to_id ] + return res class ToyTransformerWithScoreHead(nnx.Module): diff --git a/tunix/utils/trajectory_logger.py b/tunix/utils/trajectory_logger.py index 67b4a77a..ead8ef6c 100644 --- a/tunix/utils/trajectory_logger.py +++ b/tunix/utils/trajectory_logger.py @@ -14,7 +14,11 @@ """Logging utilities for trajectory data, saving as CSV.""" +import atexit import dataclasses +import queue +import threading +import time from typing import Any from absl import logging @@ -23,7 +27,6 @@ from google.protobuf import message import pandas as pd - def _make_serializable(item: Any) -> Any: """Makes an object serializable.""" if isinstance(item, dict): @@ -49,12 +52,35 @@ def _make_serializable(item: Any) -> Any: return str(item) -def log_item(log_path: str, item: dict[str, Any] | Any): - """Logs a dictionary, dataclass or list.""" +def _get_item_name(item: Any) -> str | None: + """Returns item class name if it's a dataclass, else None.""" + if dataclasses.is_dataclass(item): + return item.__class__.__name__ + return None + + +def log_item( + log_path: str, item: dict[str, Any] | Any, suffix: str | None = None +): + """Logs a dictionary, dataclass or list to a csv file. + + The filename is determined by item type if it is a dataclass, otherwise + it defaults to 'trajectory_log.csv'. If item is a list, the type of + the first element is used. + + Args: + log_path: Directory to log to. + item: Item to log. + suffix: Optional suffix to add to filename before `.csv`. + """ if log_path is None: raise ValueError('No directory for logging provided.') + if isinstance(item, list) and not item: + logging.warning('Trying to log an empty list, skipping.') + return + logging.log_first_n(logging.INFO, f'Logging item to {log_path}', 1) if dataclasses.is_dataclass(item) or isinstance(item, (dict, list)): serialized_item = _make_serializable(item) @@ -65,11 +91,77 @@ def log_item(log_path: str, item: dict[str, Any] | Any): log_path.mkdir(parents=True, exist_ok=True) assert log_path.is_dir(), f'log_path `{log_path}` must be a directory.' - file_path = log_path / 'trajectory_log.csv' + + if isinstance(item, list): + item_name = _get_item_name(item[0]) + else: + item_name = _get_item_name(item) + + file_stem = item_name if item_name else 'trajectory_log' + filename = f'{file_stem}_{suffix}.csv' if suffix else f'{file_stem}.csv' + file_path = log_path / filename write_header = not file_path.exists() df = pd.DataFrame( serialized_item if isinstance(item, list) else [serialized_item] ) - with file_path.open('a') as f: - df.to_csv(f, header=write_header, index=False) + if str(file_path).startswith('gs://'): + if file_path.exists(): + with file_path.open('r') as f: + old_df = pd.read_csv(f) + df = pd.concat([old_df, df], ignore_index=True) + with file_path.open('w') as f: + df.to_csv(f, header=True, index=False) + else: + with file_path.open('a') as f: + df.to_csv(f, header=write_header, index=False) + + +class AsyncTrajectoryLogger: + """A logger that logs trajectories asynchronously in a background thread.""" + + def __init__(self, log_dir: str): + self._log_dir = log_dir + self._file_suffix = str(int(time.time())) + self._logging_queue = queue.Queue() + self._stopped = False + + def _worker(): + while True: + item = self._logging_queue.get() + if item is None: # Sentinel for stopping + self._logging_queue.task_done() + break + try: + log_item(self._log_dir, item, self._file_suffix) + except Exception: # pylint: disable=broad-except + logging.exception('Failed to log trajectory.') + finally: + self._logging_queue.task_done() + + self._logging_thread = threading.Thread(target=_worker, daemon=True) + self._logging_thread.start() + atexit.register(self.stop) + logging.info('Started trajectory logging thread.') + + def __del__(self): + """Ensures stop is called when the object is destroyed.""" + self.stop() + + def stop(self): + """Stops the background logging thread gracefully.""" + if self._stopped: + return + logging.info('Stopping trajectory logging thread...') + self._logging_queue.put(None) + self._logging_queue.join() + self._logging_thread.join(timeout=10) + self._stopped = True + logging.info('Stopped trajectory logging thread.') + + def log_item_async(self, item: dict[str, Any] | Any): + """Adds an item to the logging queue to be logged asynchronously.""" + if self._stopped: + logging.warning('Trajectory logger already stopped.') + return + self._logging_queue.put(item) diff --git a/uv.lock b/uv.lock new file mode 100644 index 00000000..817762b4 --- /dev/null +++ b/uv.lock @@ -0,0 +1,4487 @@ +version = 1 +revision = 3 +requires-python = ">=3.11" +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version < '3.12' and sys_platform == 'win32'", + "python_full_version < '3.12' and sys_platform == 'emscripten'", + "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] + +[[package]] +name = "absl-py" +version = "2.4.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/absl-py/absl_py-2.4.0.tar.gz", hash = "sha256:8c6af82722b35cf71e0f4d1d47dcaebfff286e27110a99fc359349b247dfb5d4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/absl-py/absl_py-2.4.0-py3-none-any.whl", hash = "sha256:88476fd881ca8aab94ffa78b7b6c632a782ab3ba1cd19c9bd423abc4fb4cd28d" }, +] + +[[package]] +name = "accessible-pygments" +version = "0.0.5" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/accessible-pygments/accessible_pygments-0.0.5.tar.gz", hash = "sha256:40918d3e6a2b619ad424cb91e556bd3bd8865443d9f22f1dcdf79e33c8046872" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/accessible-pygments/accessible_pygments-0.0.5-py3-none-any.whl", hash = "sha256:88ae3211e68a1d0b011504b2ffc1691feafce124b845bd072ab6f9f66f34d4b7" }, +] + +[[package]] +name = "aiofiles" +version = "25.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiofiles/aiofiles-25.1.0.tar.gz", hash = "sha256:a8d728f0a29de45dc521f18f07297428d56992a742f0cd2701ba86e44d23d5b2" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiofiles/aiofiles-25.1.0-py3-none-any.whl", hash = "sha256:abe311e527c862958650f9438e859c1fa7568a141b22abcd015e120e86a85695" }, +] + +[[package]] +name = "aiohappyeyeballs" +version = "2.6.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohappyeyeballs/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohappyeyeballs/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8" }, +] + +[[package]] +name = "aiohttp" +version = "3.13.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3.tar.gz", hash = "sha256:a949eee43d3782f2daae4f4a2819b2cb9b0c5d3b7f7a927067cc84dafdbb9f88" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5b6073099fb654e0a068ae678b10feff95c5cae95bbfcbfa7af669d361a8aa6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cb93e166e6c28716c8c6aeb5f99dfb6d5ccf482d29fe9bf9a794110e6d0ab64" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:28e027cf2f6b641693a09f631759b4d9ce9165099d2b5d92af9bd4e197690eea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3b61b7169ababd7802f9568ed96142616a9118dd2be0d1866e920e77ec8fa92a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:80dd4c21b0f6237676449c6baaa1039abae86b91636b6c91a7f8e61c87f89540" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:65d2ccb7eabee90ce0503c17716fc77226be026dcc3e65cce859a30db715025b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5b179331a481cb5529fca8b432d8d3c7001cb217513c94cd72d668d1248688a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d4c940f02f49483b18b079d1c27ab948721852b281f8b015c058100e9421dd1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f9444f105664c4ce47a2a7171a2418bce5b7bae45fb610f4e2c36045d85911d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:694976222c711d1d00ba131904beb60534f93966562f64440d0c9d41b8cdb440" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f33ed1a2bf1997a36661874b017f5c4b760f41266341af36febaf271d179f6d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e636b3c5f61da31a92bf0d91da83e58fdfa96f178ba682f11d24f31944cdd28c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:5d2d94f1f5fcbe40838ac51a6ab5704a6f9ea42e72ceda48de5e6b898521da51" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2be0e9ccf23e8a94f6f0650ce06042cefc6ac703d0d7ab6c7a917289f2539ad4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9af5e68ee47d6534d36791bbe9b646d2a7c7deb6fc24d7943628edfbb3581f29" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-win32.whl", hash = "sha256:a2212ad43c0833a873d0fb3c63fa1bacedd4cf6af2fee62bf4b739ceec3ab239" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp311-cp311-win_amd64.whl", hash = "sha256:642f752c3eb117b105acbd87e2c143de710987e09860d674e068c4c2c441034f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:b903a4dfee7d347e2d87697d0713be59e0b87925be030c9178c5faa58ea58d5c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:a45530014d7a1e09f4a55f4f43097ba0fd155089372e105e4bff4ca76cb1b168" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:27234ef6d85c914f9efeb77ff616dbf4ad2380be0cda40b4db086ffc7ddd1b7d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d32764c6c9aafb7fb55366a224756387cd50bfa720f32b88e0e6fa45b27dcf29" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b1a6102b4d3ebc07dad44fbf07b45bb600300f15b552ddf1851b5390202ea2e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c014c7ea7fb775dd015b2d3137378b7be0249a448a1612268b5a90c2d81de04d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2b8d8ddba8f95ba17582226f80e2de99c7a7948e66490ef8d947e272a93e9463" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ae8dd55c8e6c4257eae3a20fd2c8f41edaea5992ed67156642493b8daf3cecc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:01ad2529d4b5035578f5081606a465f3b814c542882804e2e8cda61adf5c71bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bb4f7475e359992b580559e008c598091c45b5088f28614e855e42d39c2f1033" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:c19b90316ad3b24c69cd78d5c9b4f3aa4497643685901185b65166293d36a00f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:96d604498a7c782cb15a51c406acaea70d8c027ee6b90c569baa6e7b93073679" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:084911a532763e9d3dd95adf78a78f4096cd5f58cdc18e6fdbc1b58417a45423" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7a4a94eb787e606d0a09404b9c38c113d3b099d508021faa615d70a0131907ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:87797e645d9d8e222e04160ee32aa06bc5c163e8499f24db719e7852ec23093a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-win32.whl", hash = "sha256:b04be762396457bef43f3597c991e192ee7da460a4953d7e647ee4b1c28e7046" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp312-cp312-win_amd64.whl", hash = "sha256:e3531d63d3bdfa7e3ac5e9b27b2dd7ec9df3206a98e0b3445fa906f233264c57" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:5dff64413671b0d3e7d5918ea490bdccb97a4ad29b3f311ed423200b2203e01c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:87b9aab6d6ed88235aa2970294f496ff1a1f9adcd724d800e9b952395a80ffd9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:425c126c0dc43861e22cb1c14ba4c8e45d09516d0a3ae0a3f7494b79f5f233a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7f9120f7093c2a32d9647abcaf21e6ad275b4fbec5b55969f978b1a97c7c86bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:697753042d57f4bf7122cab985bf15d0cef23c770864580f5af4f52023a56bd6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6de499a1a44e7de70735d0b39f67c8f25eb3d91eb3103be99ca0fa882cdd987d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:37239e9f9a7ea9ac5bf6b92b0260b01f8a22281996da609206a84df860bc1261" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f76c1e3fe7d7c8afad7ed193f89a292e1999608170dcc9751a7462a87dfd5bc0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fc290605db2a917f6e81b0e1e0796469871f5af381ce15c604a3c5c7e51cb730" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4021b51936308aeea0367b8f006dc999ca02bc118a0cc78c303f50a2ff6afb91" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:49a03727c1bba9a97d3e93c9f93ca03a57300f484b6e935463099841261195d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3d9908a48eb7416dc1f4524e69f1d32e5d90e3981e4e37eb0aa1cd18f9cfa2a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:2712039939ec963c237286113c68dbad80a82a4281543f3abf766d9d73228998" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:7bfdc049127717581866fa4708791220970ce291c23e28ccf3922c700740fdc0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8057c98e0c8472d8846b9c79f56766bcc57e3e8ac7bfd510482332366c56c591" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-win32.whl", hash = "sha256:1449ceddcdbcf2e0446957863af03ebaaa03f94c090f945411b61269e2cb5daf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp313-cp313-win_amd64.whl", hash = "sha256:693781c45a4033d31d4187d2436f5ac701e7bbfe5df40d917736108c1cc7436e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:ea37047c6b367fd4bd632bff8077449b8fa034b69e812a18e0132a00fae6e808" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:6fc0e2337d1a4c3e6acafda6a78a39d4c14caea625124817420abceed36e2415" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c685f2d80bb67ca8c3837823ad76196b3694b0159d232206d1e461d3d434666f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e377758516d262bde50c2584fc6c578af272559c409eecbdd2bae1601184d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:34749271508078b261c4abb1767d42b8d0c0cc9449c73a4df494777dc55f0687" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:82611aeec80eb144416956ec85b6ca45a64d76429c1ed46ae1b5f86c6e0c9a26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2fff83cfc93f18f215896e3a190e8e5cb413ce01553901aca925176e7568963a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bbe7d4cecacb439e2e2a8a1a7b935c25b812af7a5fd26503a66dadf428e79ec1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b928f30fe49574253644b1ca44b1b8adbd903aa0da4b9054a6c20fc7f4092a25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7b5e8fe4de30df199155baaf64f2fcd604f4c678ed20910db8e2c66dc4b11603" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:8542f41a62bcc58fc7f11cf7c90e0ec324ce44950003feb70640fc2a9092c32a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:5e1d8c8b8f1d91cd08d8f4a3c2b067bfca6ec043d3ff36de0f3a715feeedf926" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:90455115e5da1c3c51ab619ac57f877da8fd6d73c05aacd125c5ae9819582aba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:042e9e0bcb5fba81886c8b4fbb9a09d6b8a00245fd8d88e4d989c1f96c74164c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2eb752b102b12a76ca02dff751a801f028b4ffbbc478840b473597fc91a9ed43" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-win32.whl", hash = "sha256:b556c85915d8efaed322bf1bdae9486aa0f3f764195a0fb6ee962e5c71ef5ce1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314-win_amd64.whl", hash = "sha256:9bf9f7a65e7aa20dd764151fb3d616c81088f91f8df39c3893a536e279b4b984" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:05861afbbec40650d8a07ea324367cb93e9e8cc7762e04dd4405df99fa65159c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2fc82186fadc4a8316768d61f3722c230e2c1dcab4200d52d2ebdf2482e47592" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0add0900ff220d1d5c5ebbf99ed88b0c1bbf87aa7e4262300ed1376a6b13414f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:568f416a4072fbfae453dcf9a99194bbb8bdeab718e08ee13dfa2ba0e4bebf29" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:add1da70de90a2569c5e15249ff76a631ccacfe198375eead4aadf3b8dc849dc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:10b47b7ba335d2e9b1239fa571131a87e2d8ec96b333e68b2a305e7a98b0bae2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3dd4dce1c718e38081c8f35f323209d4c1df7d4db4bab1b5c88a6b4d12b74587" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34bac00a67a812570d4a460447e1e9e06fae622946955f939051e7cc895cfab8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:a19884d2ee70b06d9204b2727a7b9f983d0c684c650254679e716b0b77920632" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5f8ca7f2bb6ba8348a3614c7918cc4bb73268c5ac2a207576b7afea19d3d9f64" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:b0d95340658b9d2f11d9697f59b3814a9d3bb4b7a7c20b131df4bcef464037c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1e53262fd202e4b40b70c3aff944a8155059beedc8a89bba9dc1f9ef06a1b56" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:d60ac9663f44168038586cab2157e122e46bdef09e9368b37f2d82d354c23f72" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:90751b8eed69435bac9ff4e3d2f6b3af1f57e37ecb0fbeee59c0174c9e2d41df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fc353029f176fd2b3ec6cfc71be166aba1936fe5d73dd1992ce289ca6647a9aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-win32.whl", hash = "sha256:2e41b18a58da1e474a057b3d35248d8320029f61d70a37629535b16a0c8f3767" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiohttp/aiohttp-3.13.3-cp314-cp314t-win_amd64.whl", hash = "sha256:44531a36aa2264a1860089ffd4dce7baf875ee5a6079d5fb42e261c704ef7344" }, +] + +[[package]] +name = "aiosignal" +version = "1.4.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "frozenlist" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiosignal/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/aiosignal/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e" }, +] + +[[package]] +name = "alabaster" +version = "1.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/alabaster/alabaster-1.0.0.tar.gz", hash = "sha256:c00dca57bca26fa62a6d7d0a9fcce65f3e026e9bfe33e9c538fd3fbb2144fd9e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/alabaster/alabaster-1.0.0-py3-none-any.whl", hash = "sha256:fc6786402dc3fcb2de3cabd5fe455a2db534b371124f1f21de8731783dec828b" }, +] + +[[package]] +name = "antlr4-python3-runtime" +version = "4.9.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/antlr4-python3-runtime/antlr4-python3-runtime-4.9.3.tar.gz", hash = "sha256:f224469b4168294902bb1efa80a8bf7855f24c99aef99cbefc1bcd3cce77881b" } + +[[package]] +name = "anyio" +version = "4.12.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "idna" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/anyio/anyio-4.12.1.tar.gz", hash = "sha256:41cfcc3a4c85d3f05c932da7c26d0201ac36f72abd4435ba90d0464a3ffed703" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/anyio/anyio-4.12.1-py3-none-any.whl", hash = "sha256:d405828884fc140aa80a3c667b8beed277f1dfedec42ba031bd6ac3db606ab6c" }, +] + +[[package]] +name = "appnope" +version = "0.1.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/appnope/appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/appnope/appnope-0.1.4-py2.py3-none-any.whl", hash = "sha256:502575ee11cd7a28c0205f379b525beefebab9d161b7c964670864014ed7213c" }, +] + +[[package]] +name = "array-record" +version = "0.8.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "etils", extra = ["epath"] }, +] +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8a0caee17d2583638391fb9f90c9c12a43f9665576f18ec3604ba49d62bd2dcc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9f91636366038afea55061cc539601e353d04ebf32608ae8717df4a4edbd31df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f4004fcceb7961a2cc0090028e68a3eeb91d3f5b38c00d60b533f7004d1d3f7b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:dada305fa0dfa3fd6f5f263c43ed37546f815e4f33ce30b066175384dead752e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:718403dc9a364519a5fc440ed9e2784077e965489d5a44c96970d3101101e1cd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:458f6658de86c9369b23ffe64dcb31393a919b91ae2f15147ee2beb2010b122a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:fa94fa053c1afaecc183a1c31463fd89d1b7b148cc526095bfc50ab58967e47c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:adfe6c92918363747539c0caa579f568f75aac079ad7bbd4ebcf7fdb02e5461b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:13df1aec9b38afe98973bf5fe3cf523f83ca904b0423d85319930877145b8f28" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:14facb713fc55ea612cf853c0abbc602032ae619eb85037af3aa41dc4e27eed6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:06b17a0a90bc74a80c4ebad0b99f0e039adb01746b673db3d7a5632d8b138ddd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/array-record/array_record-0.8.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89d2cf5f4709be3c6c2b30c0d366005223375633ffce66dcb13d927a0bdc5228" }, +] + +[[package]] +name = "asttokens" +version = "3.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/asttokens/asttokens-3.0.1.tar.gz", hash = "sha256:71a4ee5de0bde6a31d64f6b13f2293ac190344478f081c3d1bccfcf5eacb0cb7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/asttokens/asttokens-3.0.1-py3-none-any.whl", hash = "sha256:15a3ebc0f43c2d0a50eeafea25e19046c68398e487b9f1f5b517f7c0f40f976a" }, +] + +[[package]] +name = "attrs" +version = "25.4.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/attrs/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/attrs/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373" }, +] + +[[package]] +name = "babel" +version = "2.18.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/babel/babel-2.18.0.tar.gz", hash = "sha256:b80b99a14bd085fcacfa15c9165f651fbb3406e66cc603abf11c5750937c992d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/babel/babel-2.18.0-py3-none-any.whl", hash = "sha256:e2b422b277c2b9a9630c1d7903c2a00d0830c409c59ac8cae9081c92f1aeba35" }, +] + +[[package]] +name = "beautifulsoup4" +version = "4.14.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "soupsieve" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/beautifulsoup4/beautifulsoup4-4.14.3.tar.gz", hash = "sha256:6292b1c5186d356bba669ef9f7f051757099565ad9ada5dd630bd9de5fa7fb86" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/beautifulsoup4/beautifulsoup4-4.14.3-py3-none-any.whl", hash = "sha256:0918bfe44902e6ad8d57732ba310582e98da931428d231a5ecb9e7c703a735bb" }, +] + +[[package]] +name = "certifi" +version = "2026.1.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/certifi/certifi-2026.1.4.tar.gz", hash = "sha256:ac726dd470482006e014ad384921ed6438c457018f4b3d204aea4281258b2120" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/certifi/certifi-2026.1.4-py3-none-any.whl", hash = "sha256:9943707519e4add1115f44c2bc244f782c0249876bf51b6599fee1ffbedd685c" }, +] + +[[package]] +name = "cffi" +version = "2.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:b4c854ef3adc177950a8dfc81a86f5115d2abd545751a304c5bcf2c2c7283cfe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2de9a304e27f7596cd03d16f1b7c72219bd944e99cc52b84d0145aefb07cbd3c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:baf5215e0ab74c16e2dd324e8ec067ef59e41125d3eade2b863d294fd5035c92" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:730cacb21e1bdff3ce90babf007d0a0917cc3e6492f336c2f0134101e0944f93" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:6824f87845e3396029f3820c206e459ccc91760e8fa24422f8b0c3d1731cbec5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:9de40a7b0323d889cf8d23d1ef214f565ab154443c42737dfe52ff82cf857664" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8941aaadaf67246224cee8c3803777eed332a19d909b47e29c9842ef1e79ac26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a05d0c237b3349096d3981b727493e22147f934b20f6f125a3eba8f994bec4a9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:94698a9c5f91f9d138526b48fe26a199609544591f859c870d477351dc7b2414" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:5fed36fccc0612a53f1d4d9a816b50a36702c28a2aa880cb8a122b3466638743" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-win32.whl", hash = "sha256:c649e3a33450ec82378822b3dad03cc228b8f5963c0c12fc3b1e0ab940f768a5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:66f011380d0e49ed280c789fbd08ff0d40968ee7b665575489afa95c98196ab5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:c6638687455baf640e37344fe26d37c404db8b80d037c3d29f58fe8d1c3b194d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6d02d6655b0e54f54c4ef0b94eb6be0607b70853c45ce98bd278dc7de718be5d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8eca2a813c1cb7ad4fb74d368c2ffbbb4789d377ee5bb8df98373c2cc0dee76c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:21d1152871b019407d8ac3985f6775c079416c282e431a4da6afe7aefd2bccbe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b21e08af67b8a103c71a250401c78d5e0893beff75e28c53c98f4de42f774062" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:1e3a615586f05fc4065a8b22b8152f0c1b00cdbc60596d187c2a74f9e3036e4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:81afed14892743bbe14dacb9e36d9e0e504cd204e0b165062c488942b9718037" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3e17ed538242334bf70832644a32a7aae3d83b57567f9fd60a26257e992b79ba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3925dd22fa2b7699ed2617149842d2e6adde22b262fcbfada50e3d195e4b3a94" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:2c8f814d84194c9ea681642fd164267891702542f028a15fc97d4674b6206187" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-win32.whl", hash = "sha256:da902562c3e9c550df360bfa53c035b2f241fed6d9aef119048073680ace4a18" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:da68248800ad6320861f129cd9c1bf96ca849a2771a59e0344e88681905916f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:4671d9dd5ec934cb9a73e7ee9676f9362aba54f7f34910956b84d727b0d73fb6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:00bdf7acc5f795150faa6957054fbbca2439db2f775ce831222b66f192f03beb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:45d5e886156860dc35862657e1494b9bae8dfa63bf56796f2fb56e1679fc0bca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-manylinux1_i686.manylinux2014_i686.manylinux_2_17_i686.manylinux_2_5_i686.whl", hash = "sha256:07b271772c100085dd28b74fa0cd81c8fb1a3ba18b21e03d7c27f3436a10606b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d48a880098c96020b02d5a1f7d9251308510ce8858940e6fa99ece33f610838b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:f93fd8e5c8c0a4aa1f424d6173f14a892044054871c771f8566e4008eaa359d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:dd4f05f54a52fb558f1ba9f528228066954fee3ebe629fc1660d874d040ae5a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c8d3b5532fc71b7a77c09192b4a5a200ea992702734a2e9279a37f2478236f26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d9b29c1f0ae438d5ee9acb31cadee00a58c46cc9c0b2f9038c6b0b3470877a8c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6d50360be4546678fc1b79ffe7a66265e28667840010348dd69a314145807a1b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-win32.whl", hash = "sha256:74a03b9698e198d47562765773b4a8309919089150a0bb17d829ad7b44b60d27" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:19f705ada2530c1167abacb171925dd886168931e0a7b78f5bffcae5c6b5be75" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:256f80b80ca3853f90c21b23ee78cd008713787b1b1e93eae9f3d6a7134abd91" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fc33c5141b55ed366cfaad382df24fe7dcbc686de5be719b207bb248e3053dc5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c654de545946e0db659b3400168c9ad31b5d29593291482c43e3564effbcee13" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:24b6f81f1983e6df8db3adc38562c83f7d4a0c36162885ec7f7b77c7dcbec97b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:12873ca6cb9b0f0d3a0da705d6086fe911591737a59f28b7936bdfed27c0d47c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:d9b97165e8aed9272a6bb17c01e3cc5871a594a446ebedc996e2397a1c1ea8ef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:afb8db5439b81cf9c9d0c80404b60c3cc9c3add93e114dcae767f1477cb53775" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:737fe7d37e1a1bffe70bd5754ea763a62a066dc5913ca57e957824b72a85e205" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:38100abb9d1b1435bc4cc340bb4489635dc2f0da7456590877030c9b3d40b0c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-win32.whl", hash = "sha256:087067fa8953339c723661eda6b54bc98c5625757ea62e95eb4898ad5e776e9f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-win_amd64.whl", hash = "sha256:203a48d1fb583fc7d78a4c6655692963b860a417c0528492a6bc21f1aaefab25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314-win_arm64.whl", hash = "sha256:dbd5c7a25a7cb98f5ca55d258b103a2054f859a46ae11aaf23134f9cc0d356ad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:9a67fc9e8eb39039280526379fb3a70023d77caec1852002b4da7e8b270c4dd9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7a66c7204d8869299919db4d5069a82f1561581af12b11b3c9f48c584eb8743d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:7cc09976e8b56f8cebd752f7113ad07752461f48a58cbba644139015ac24954c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.whl", hash = "sha256:92b68146a71df78564e4ef48af17551a5ddd142e5190cdf2c5624d0c3ff5b2e8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.whl", hash = "sha256:b1e74d11748e7e98e2f426ab176d4ed720a64412b6a15054378afdb71e0f37dc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:28a3a209b96630bca57cce802da70c266eb08c6e97e5afd61a75611ee6c64592" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:7553fb2090d71822f02c629afe6042c299edf91ba1bf94951165613553984512" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6c6c373cfc5c83a975506110d17457138c8c63016b563cc9ed6e056a82f13ce4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-win32.whl", hash = "sha256:1fc9ea04857caf665289b7a75923f2c6ed559b8298a1b8c49e59f7dd95c8481e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-win_amd64.whl", hash = "sha256:d68b6cef7827e8641e8ef16f4494edda8b36104d79773a334beaa1e3521430f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cffi/cffi-2.0.0-cp314-cp314t-win_arm64.whl", hash = "sha256:0a1527a803f0a659de1af2e1fd700213caba79377e27e4693648c2923da066f9" }, +] + +[[package]] +name = "charset-normalizer" +version = "3.4.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4.tar.gz", hash = "sha256:94537985111c35f28720e43603b8e7b43a6ecfb2ce1d3058bbe955b73404e21a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6e1fcf0720908f200cd21aa4e6750a48ff6ce4afe7ff5a79a90d5ed8a08296f8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f819d5fe9234f9f82d75bdfa9aef3a3d72c4d24a6e57aeaebba32a704553aa0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:a59cb51917aa591b1c4e6a43c132f0cdc3c76dbad6155df4e28ee626cc77a0a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8ef3c867360f88ac904fd3f5e1f902f13307af9052646963ee08ff4f131adafc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d9e45d7faa48ee908174d8fe84854479ef838fc6a705c9315372eacbc2f02897" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:840c25fb618a231545cbab0564a799f101b63b9901f2569faecd6b222ac72381" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ca5862d5b3928c4940729dacc329aa9102900382fea192fc5e52eb69d6093815" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9c7f57c3d666a53421049053eaacdd14bbd0a528e2186fcb2e672effd053bb0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:277e970e750505ed74c832b4bf75dac7476262ee2a013f5574dd49075879e161" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:31fd66405eaf47bb62e8cd575dc621c56c668f27d46a61d975a249930dd5e2a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:0d3d8f15c07f86e9ff82319b3d9ef6f4bf907608f53fe9d92b28ea9ae3d1fd89" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:9f7fcd74d410a36883701fafa2482a6af2ff5ba96b9a620e9e0721e28ead5569" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf3e58c7ec8a8bed6d66a75d7fb37b55e5015b03ceae72a8e7c74495551e224" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-win32.whl", hash = "sha256:eecbc200c7fd5ddb9a7f16c7decb07b566c29fa2161a16cf67b8d068bd21690a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-win_amd64.whl", hash = "sha256:5ae497466c7901d54b639cf42d5b8c1b6a4fead55215500d2f486d34db48d016" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp311-cp311-win_arm64.whl", hash = "sha256:65e2befcd84bc6f37095f5961e68a6f077bf44946771354a28ad434c2cce0ae1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0a98e6759f854bd25a58a73fa88833fba3b7c491169f86ce1180c948ab3fd394" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b5b290ccc2a263e8d185130284f8501e3e36c5e02750fc6b6bdeb2e9e96f1e25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74bb723680f9f7a6234dcf67aea57e708ec1fbdf5699fb91dfd6f511b0a320ef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f1e34719c6ed0b92f418c7c780480b26b5d9c50349e9a9af7d76bf757530350d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2437418e20515acec67d86e12bf70056a33abdacb5cb1655042f6538d6b085a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11d694519d7f29d6cd09f6ac70028dba10f92f6cdd059096db198c283794ac86" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:ac1c4a689edcc530fc9d9aa11f5774b9e2f33f9a0c6a57864e90908f5208d30a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:21d142cc6c0ec30d2efee5068ca36c128a30b0f2c53c1c07bd78cb6bc1d3be5f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:5dbe56a36425d26d6cfb40ce79c314a2e4dd6211d51d6d2191c00bed34f354cc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:5bfbb1b9acf3334612667b61bd3002196fe2a1eb4dd74d247e0f2a4d50ec9bbf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:d055ec1e26e441f6187acf818b73564e6e6282709e9bcb5b63f5b23068356a15" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:af2d8c67d8e573d6de5bc30cdb27e9b95e49115cd9baad5ddbd1a6207aaa82a9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:780236ac706e66881f3b7f2f32dfe90507a09e67d1d454c762cf642e6e1586e0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-win32.whl", hash = "sha256:5833d2c39d8896e4e19b689ffc198f08ea58116bee26dea51e362ecc7cd3ed26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-win_amd64.whl", hash = "sha256:a79cfe37875f822425b89a82333404539ae63dbdddf97f84dcbc3d339aae9525" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp312-cp312-win_arm64.whl", hash = "sha256:376bec83a63b8021bb5c8ea75e21c4ccb86e7e45ca4eb81146091b56599b80c3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e1f185f86a6f3403aa2420e815904c67b2f9ebc443f045edd0de921108345794" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b39f987ae8ccdf0d2642338faf2abb1862340facc796048b604ef14919e55ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3162d5d8ce1bb98dd51af660f2121c55d0fa541b46dff7bb9b9f86ea1d87de72" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:81d5eb2a312700f4ecaa977a8235b634ce853200e828fbadf3a9c50bab278328" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5bd2293095d766545ec1a8f612559f6b40abc0eb18bb2f5d1171872d34036ede" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a8a8b89589086a25749f471e6a900d3f662d1d3b6e2e59dcecf787b1cc3a1894" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc7637e2f80d8530ee4a78e878bce464f70087ce73cf7c1caf142416923b98f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f8bf04158c6b607d747e93949aa60618b61312fe647a6369f88ce2ff16043490" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:554af85e960429cf30784dd47447d5125aaa3b99a6f0683589dbd27e2f45da44" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:74018750915ee7ad843a774364e13a3db91682f26142baddf775342c3f5b1133" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:c0463276121fdee9c49b98908b3a89c39be45d86d1dbaa22957e38f6321d4ce3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362d61fd13843997c1c446760ef36f240cf81d3ebf74ac62652aebaf7838561e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a26f18905b8dd5d685d6d07b0cdf98a79f3c7a918906af7cc143ea2e164c8bc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-win32.whl", hash = "sha256:9b35f4c90079ff2e2edc5b26c0c77925e5d2d255c42c74fdb70fb49b172726ac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-win_amd64.whl", hash = "sha256:b435cba5f4f750aa6c0a0d92c541fb79f69a387c91e61f1795227e4ed9cece14" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp313-cp313-win_arm64.whl", hash = "sha256:542d2cee80be6f80247095cc36c418f7bddd14f4a6de45af91dfad36d817bba2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:da3326d9e65ef63a817ecbcc0df6e94463713b754fe293eaa03da99befb9a5bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8af65f14dc14a79b924524b1e7fffe304517b2bff5a58bf64f30b98bbc5079eb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:74664978bb272435107de04e36db5a9735e78232b85b77d45cfb38f758efd33e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:752944c7ffbfdd10c074dc58ec2d5a8a4cd9493b314d367c14d24c17684ddd14" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1f13550535ad8cff21b8d757a3257963e951d96e20ec82ab44bc64aeb62a191" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ecaae4149d99b1c9e7b88bb03e3221956f68fd6d50be2ef061b2381b61d20838" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:cb6254dc36b47a990e59e1068afacdcd02958bdcce30bb50cc1700a8b9d624a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c8ae8a0f02f57a6e61203a31428fa1d677cbe50c93622b4149d5c0f319c1d19e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:47cc91b2f4dd2833fddaedd2893006b0106129d4b94fdb6af1f4ce5a9965577c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:82004af6c302b5d3ab2cfc4cc5f29db16123b1a8417f2e25f9066f91d4411090" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:2b7d8f6c26245217bd2ad053761201e9f9680f8ce52f0fcd8d0755aeae5b2152" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:799a7a5e4fb2d5898c60b640fd4981d6a25f1c11790935a44ce38c54e985f828" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:99ae2cffebb06e6c22bdc25801d7b30f503cc87dbd283479e7b606f70aff57ec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-win32.whl", hash = "sha256:f9d332f8c2a2fcbffe1378594431458ddbef721c1769d78e2cbc06280d8155f9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-win_amd64.whl", hash = "sha256:8a6562c3700cce886c5be75ade4a5db4214fda19fede41d9792d100288d8f94c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-cp314-cp314-win_arm64.whl", hash = "sha256:de00632ca48df9daf77a2c65a484531649261ec9f25489917f09e455cb09ddb2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/charset-normalizer/charset_normalizer-3.4.4-py3-none-any.whl", hash = "sha256:7a32c560861a02ff789ad905a2fe94e3f840803362c84fecf1851cb4cf3dc37f" }, +] + +[[package]] +name = "chex" +version = "0.1.91" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, + { name = "toolz" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/chex/chex-0.1.91.tar.gz", hash = "sha256:65367a521415ada905b8c0222b0a41a68337fcadf79a1fb6fc992dbd95dd9f76" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/chex/chex-0.1.91-py3-none-any.whl", hash = "sha256:6fc4cbfc22301c08d4a7ef706045668410100962eba8ba6af03fa07f4e5dcf9b" }, +] + +[[package]] +name = "click" +version = "8.3.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/click/click-8.3.1.tar.gz", hash = "sha256:12ff4785d337a1bb490bb7e9c2b1ee5da3112e94a8622f26a6c77f5d2fc6842a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/click/click-8.3.1-py3-none-any.whl", hash = "sha256:981153a64e25f12d547d3426c367a4857371575ee7ad18df2a6183ab0545b2a6" }, +] + +[[package]] +name = "cloudpickle" +version = "3.1.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cloudpickle/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cloudpickle/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a" }, +] + +[[package]] +name = "clu" +version = "0.0.12" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "etils", extra = ["epath"] }, + { name = "flax" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "ml-collections" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "typing-extensions" }, + { name = "wrapt" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/clu/clu-0.0.12.tar.gz", hash = "sha256:f71eaa1afbd30f57f7709257ba7e1feb8ad5c1c3dcae3606672a138678bb3ce4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/clu/clu-0.0.12-py3-none-any.whl", hash = "sha256:0d183e7d25f7dd0700444510a264e24700e2f068bdabd199ed22866f7e54edba" }, +] + +[[package]] +name = "colorama" +version = "0.4.6" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/colorama/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/colorama/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6" }, +] + +[[package]] +name = "comm" +version = "0.2.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/comm/comm-0.2.3.tar.gz", hash = "sha256:2dc8048c10962d55d7ad693be1e7045d891b7ce8d999c97963a5e3e99c055971" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/comm/comm-0.2.3-py3-none-any.whl", hash = "sha256:c615d91d75f7f04f095b30d1c1711babd43bdc6419c1be9886a85f2f4e489417" }, +] + +[[package]] +name = "contourpy" +version = "1.3.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:709a48ef9a690e1343202916450bc48b9e51c049b089c7f79a267b46cffcdaa1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:23416f38bfd74d5d28ab8429cc4d63fa67d5068bd711a85edb1c3fb0c3e2f381" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:929ddf8c4c7f348e4c0a5a3a714b5c8542ffaa8c22954862a46ca1813b667ee7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9e999574eddae35f1312c2b4b717b7885d4edd6cb46700e04f7f02db454e67c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf67e0e3f482cb69779dd3061b534eb35ac9b17f163d851e2a547d56dba0a3a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51e79c1f7470158e838808d4a996fa9bac72c498e93d8ebe5119bc1e6becb0db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:598c3aaece21c503615fd59c92a3598b428b2f01bfb4b8ca9c4edeecc2438620" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:322ab1c99b008dad206d406bb61d014cf0174df491ae9d9d0fac6a6fda4f977f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-win32.whl", hash = "sha256:fd907ae12cd483cd83e414b12941c632a969171bf90fc937d0c9f268a31cafff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-win_amd64.whl", hash = "sha256:3519428f6be58431c56581f1694ba8e50626f2dd550af225f82fb5f5814d2a42" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp311-cp311-win_arm64.whl", hash = "sha256:15ff10bfada4bf92ec8b31c62bf7c1834c244019b4a33095a68000d7075df470" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b08a32ea2f8e42cf1d4be3169a98dd4be32bafe4f22b6c4cb4ba810fa9e5d2cb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:556dba8fb6f5d8742f2923fe9457dbdd51e1049c4a43fd3986a0b14a1d815fc6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92d9abc807cf7d0e047b95ca5d957cf4792fcd04e920ca70d48add15c1a90ea7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b2e8faa0ed68cb29af51edd8e24798bb661eac3bd9f65420c1887b6ca89987c8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:626d60935cf668e70a5ce6ff184fd713e9683fb458898e4249b63be9e28286ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4d00e655fcef08aba35ec9610536bfe90267d7ab5ba944f7032549c55a146da1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:451e71b5a7d597379ef572de31eeb909a87246974d960049a9848c3bc6c41bf7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:459c1f020cd59fcfe6650180678a9993932d80d44ccde1fa1868977438f0b411" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-win32.whl", hash = "sha256:023b44101dfe49d7d53932be418477dba359649246075c996866106da069af69" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-win_amd64.whl", hash = "sha256:8153b8bfc11e1e4d75bcb0bff1db232f9e10b274e0929de9d608027e0d34ff8b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp312-cp312-win_arm64.whl", hash = "sha256:07ce5ed73ecdc4a03ffe3e1b3e3c1166db35ae7584be76f65dbbe28a7791b0cc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:177fb367556747a686509d6fef71d221a4b198a3905fe824430e5ea0fda54eb5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:d002b6f00d73d69333dac9d0b8d5e84d9724ff9ef044fd63c5986e62b7c9e1b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:348ac1f5d4f1d66d3322420f01d42e43122f43616e0f194fc1c9f5d830c5b286" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:655456777ff65c2c548b7c454af9c6f33f16c8884f11083244b5819cc214f1b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:644a6853d15b2512d67881586bd03f462c7ab755db95f16f14d7e238f2852c67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4debd64f124ca62069f313a9cb86656ff087786016d76927ae2cf37846b006c9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a15459b0f4615b00bbd1e91f1b9e19b7e63aea7483d03d804186f278c0af2659" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:ca0fdcd73925568ca027e0b17ab07aad764be4706d0a925b89227e447d9737b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-win32.whl", hash = "sha256:b20c7c9a3bf701366556e1b1984ed2d0cedf999903c51311417cf5f591d8c78d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-win_amd64.whl", hash = "sha256:1cadd8b8969f060ba45ed7c1b714fe69185812ab43bd6b86a9123fe8f99c3263" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313-win_arm64.whl", hash = "sha256:fd914713266421b7536de2bfa8181aa8c699432b6763a0ea64195ebe28bff6a9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:88df9880d507169449d434c293467418b9f6cbe82edd19284aa0409e7fdb933d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:d06bb1f751ba5d417047db62bca3c8fde202b8c11fb50742ab3ab962c81e8216" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e4e6b05a45525357e382909a4c1600444e2a45b4795163d3b22669285591c1ae" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ab3074b48c4e2cf1a960e6bbeb7f04566bf36b1861d5c9d4d8ac04b82e38ba20" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c3d53c796f8647d6deb1abe867daeb66dcc8a97e8455efa729516b997b8ed99" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50ed930df7289ff2a8d7afeb9603f8289e5704755c7e5c3bbd929c90c817164b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4feffb6537d64b84877da813a5c30f1422ea5739566abf0bd18065ac040e120a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:2b7e9480ffe2b0cd2e787e4df64270e3a0440d9db8dc823312e2c940c167df7e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-win32.whl", hash = "sha256:283edd842a01e3dcd435b1c5116798d661378d83d36d337b8dde1d16a5fc9ba3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-win_amd64.whl", hash = "sha256:87acf5963fc2b34825e5b6b048f40e3635dd547f590b04d2ab317c2619ef7ae8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp313-cp313t-win_arm64.whl", hash = "sha256:3c30273eb2a55024ff31ba7d052dde990d7d8e5450f4bbb6e913558b3d6c2301" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:fde6c716d51c04b1c25d0b90364d0be954624a0ee9d60e23e850e8d48353d07a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:cbedb772ed74ff5be440fa8eee9bd49f64f6e3fc09436d9c7d8f1c287b121d77" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:22e9b1bd7a9b1d652cd77388465dc358dafcd2e217d35552424aa4f996f524f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a22738912262aa3e254e4f3cb079a95a67132fc5a063890e224393596902f5a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:afe5a512f31ee6bd7d0dda52ec9864c984ca3d66664444f2d72e0dc4eb832e36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f64836de09927cba6f79dcd00fdd7d5329f3fccc633468507079c829ca4db4e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1fd43c3be4c8e5fd6e4f2baeae35ae18176cf2e5cced681cca908addf1cdd53b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6afc576f7b33cf00996e5c1102dc2a8f7cc89e39c0b55df93a0b78c1bd992b36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-win32.whl", hash = "sha256:66c8a43a4f7b8df8b71ee1840e4211a3c8d93b214b213f590e18a1beca458f7d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-win_amd64.whl", hash = "sha256:cf9022ef053f2694e31d630feaacb21ea24224be1c3ad0520b13d844274614fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314-win_arm64.whl", hash = "sha256:95b181891b4c71de4bb404c6621e7e2390745f887f2a026b2d99e92c17892339" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:33c82d0138c0a062380332c861387650c82e4cf1747aaa6938b9b6516762e772" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ea37e7b45949df430fe649e5de8351c423430046a2af20b1c1961cae3afcda77" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d304906ecc71672e9c89e87c4675dc5c2645e1f4269a5063b99b0bb29f232d13" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca658cd1a680a5c9ea96dc61cdbae1e85c8f25849843aa799dfd3cb370ad4fbe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-manylinux_2_26_s390x.manylinux_2_28_s390x.whl", hash = "sha256:ab2fd90904c503739a75b7c8c5c01160130ba67944a7b77bbf36ef8054576e7f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7301b89040075c30e5768810bc96a8e8d78085b47d8be6e4c3f5a0b4ed478a0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2a2a8b627d5cc6b7c41a4beff6c5ad5eb848c88255fda4a8745f7e901b32d8e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd6ec6be509c787f1caf6b247f0b1ca598bef13f4ddeaa126b7658215529ba0f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-win32.whl", hash = "sha256:e74a9a0f5e3fff48fb5a7f2fd2b9b70a3fe014a67522f79b7cca4c0c7e43c9ae" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-win_amd64.whl", hash = "sha256:13b68d6a62db8eafaebb8039218921399baf6e47bf85006fd8529f2a08ef33fc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-cp314-cp314t-win_arm64.whl", hash = "sha256:b7448cb5a725bb1e35ce88771b86fba35ef418952474492cf7c764059933ff8b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:cd5dfcaeb10f7b7f9dc8941717c6c2ade08f587be2226222c12b25f0483ed497" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0c1fc238306b35f246d61a1d416a627348b5cf0648648a031e14bb8705fcdfe8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:70f9aad7de812d6541d29d2bbf8feb22ff7e1c299523db288004e3157ff4674e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ed3657edf08512fc3fe81b510e35c2012fbd3081d2e26160f27ca28affec989" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/contourpy/contourpy-1.3.3-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:3d1a3799d62d45c18bafd41c5fa05120b96a28079f2393af559b843d1a966a77" }, +] + +[[package]] +name = "cycler" +version = "0.12.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cycler/cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/cycler/cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30" }, +] + +[[package]] +name = "dataclasses-json" +version = "0.6.7" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "marshmallow" }, + { name = "typing-inspect" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dataclasses-json/dataclasses_json-0.6.7.tar.gz", hash = "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dataclasses-json/dataclasses_json-0.6.7-py3-none-any.whl", hash = "sha256:0dbf33f26c8d5305befd61b39d2b3414e8a407bedc2834dea9b8d642666fb40a" }, +] + +[[package]] +name = "datasets" +version = "4.5.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "dill" }, + { name = "filelock" }, + { name = "fsspec", extra = ["http"] }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "multiprocess" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pyarrow" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "xxhash" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/datasets/datasets-4.5.0.tar.gz", hash = "sha256:00c698ce1c2452e646cc5fad47fef39d3fe78dd650a8a6eb205bb45eb63cd500" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/datasets/datasets-4.5.0-py3-none-any.whl", hash = "sha256:b5d7e08096ffa407dd69e58b1c0271c9b2506140839b8d99af07375ad31b6726" }, +] + +[[package]] +name = "debugpy" +version = "1.8.20" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20.tar.gz", hash = "sha256:55bc8701714969f1ab89a6d5f2f3d40c36f91b2cbe2f65d98bf8196f6a6a2c33" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp311-cp311-macosx_15_0_universal2.whl", hash = "sha256:eada6042ad88fa1571b74bd5402ee8b86eded7a8f7b827849761700aff171f1b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp311-cp311-manylinux_2_34_x86_64.whl", hash = "sha256:7de0b7dfeedc504421032afba845ae2a7bcc32ddfb07dae2c3ca5442f821c344" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp311-cp311-win32.whl", hash = "sha256:773e839380cf459caf73cc533ea45ec2737a5cc184cf1b3b796cd4fd98504fec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp311-cp311-win_amd64.whl", hash = "sha256:1f7650546e0eded1902d0f6af28f787fa1f1dbdbc97ddabaf1cd963a405930cb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp312-cp312-macosx_15_0_universal2.whl", hash = "sha256:4ae3135e2089905a916909ef31922b2d733d756f66d87345b3e5e52b7a55f13d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp312-cp312-manylinux_2_34_x86_64.whl", hash = "sha256:88f47850a4284b88bd2bfee1f26132147d5d504e4e86c22485dfa44b97e19b4b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp312-cp312-win32.whl", hash = "sha256:4057ac68f892064e5f98209ab582abfee3b543fb55d2e87610ddc133a954d390" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp312-cp312-win_amd64.whl", hash = "sha256:a1a8f851e7cf171330679ef6997e9c579ef6dd33c9098458bd9986a0f4ca52e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp313-cp313-macosx_15_0_universal2.whl", hash = "sha256:5dff4bb27027821fdfcc9e8f87309a28988231165147c31730128b1c983e282a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp313-cp313-manylinux_2_34_x86_64.whl", hash = "sha256:84562982dd7cf5ebebfdea667ca20a064e096099997b175fe204e86817f64eaf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp313-cp313-win32.whl", hash = "sha256:da11dea6447b2cadbf8ce2bec59ecea87cc18d2c574980f643f2d2dfe4862393" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp313-cp313-win_amd64.whl", hash = "sha256:eb506e45943cab2efb7c6eafdd65b842f3ae779f020c82221f55aca9de135ed7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp314-cp314-macosx_15_0_universal2.whl", hash = "sha256:9c74df62fc064cd5e5eaca1353a3ef5a5d50da5eb8058fcef63106f7bebe6173" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp314-cp314-manylinux_2_34_x86_64.whl", hash = "sha256:077a7447589ee9bc1ff0cdf443566d0ecf540ac8aa7333b775ebcb8ce9f4ecad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp314-cp314-win32.whl", hash = "sha256:352036a99dd35053b37b7803f748efc456076f929c6a895556932eaf2d23b07f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-cp314-cp314-win_amd64.whl", hash = "sha256:a98eec61135465b062846112e5ecf2eebb855305acc1dfbae43b72903b8ab5be" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/debugpy/debugpy-1.8.20-py2.py3-none-any.whl", hash = "sha256:5be9bed9ae3be00665a06acaa48f8329d2b9632f15fd09f6a9a8c8d9907e54d7" }, +] + +[[package]] +name = "decorator" +version = "5.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/decorator/decorator-5.2.1.tar.gz", hash = "sha256:65f266143752f734b0a7cc83c46f4618af75b8c5911b00ccb61d0ac9b6da0360" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/decorator/decorator-5.2.1-py3-none-any.whl", hash = "sha256:d316bb415a2d9e2d2b3abcc4084c6502fc09240e292cd76a76afc106a1c8e04a" }, +] + +[[package]] +name = "dill" +version = "0.4.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dill/dill-0.4.0.tar.gz", hash = "sha256:0633f1d2df477324f53a895b02c901fb961bdbf65a17122586ea7019292cbcf0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dill/dill-0.4.0-py3-none-any.whl", hash = "sha256:44f54bf6412c2c8464c14e8243eb163690a9800dbe2c367330883b19c7561049" }, +] + +[[package]] +name = "dm-tree" +version = "0.1.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "attrs" }, + { name = "numpy" }, + { name = "wrapt" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9.tar.gz", hash = "sha256:a4c7db3d3935a5a2d5e4b383fc26c6b0cd6f78c6d4605d3e7b518800ecd5342b" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7d7d784afaeb4b67d87d858261aaf02503939ddc1f09c4cca70728f9892ab004" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e660d1779ddcbd1348410d08f67db4870d413a3ec4ba8b4b045bd5ce4bd8f35c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:294dc1cecf87552a45cdd5ddb215e7f5295a5a47c46f1f0a0463c3dd02a527d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp311-cp311-win_amd64.whl", hash = "sha256:12f4cc6cd52a39aa38ff31577b6d79b6136a9a89273a876bf62335c9f65c27bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a8d20eeab7fde77a3ed71f07716021eb0edfb4812a128eb381d108af3a310257" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:80c43417814b1181d3367b335460bfdd30b79ee187a64220e11f6ddd093a4b15" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2334cfe9d2ed4293f9f1c7aefba0657deaab9ea74b5fadd966f6d01d9b6b42d9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp312-cp312-win_amd64.whl", hash = "sha256:9020a5ce256fcc83aa4bc190cc96dd66e87685db0a6e501b0c06aa492c2e38fc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:cfa33c2e028155810ad1b4e11928707bf47489516763a86e79cab2954d23bf68" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d05622d074353cf434049206e53c12147903a048c4bd7d77f2800d427413ad78" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f68b0efad76703dd4648586c75618a48cdd671b68c3266fe980e323c15423607" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313-win_amd64.whl", hash = "sha256:e97c34fcb44941c36b7ee81dcdbceba0fbe728bddcc77e5837ab2eb665bcbff8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:b06e7a5da1c31a82521a60060573527e8d24b9920fdd20b2ec86f08412737598" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6893fcdc5cf1a4f459cfc383526d35d42e7c671ae565d7e429a2f2cb2cb93e89" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/dm-tree/dm_tree-0.1.9-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e1f5d1e96b3a7de22b25b13a5eb30f41f8cf9c02dd4479a24920de99e780903c" }, +] + +[[package]] +name = "docstring-parser" +version = "0.17.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/docstring-parser/docstring_parser-0.17.0.tar.gz", hash = "sha256:583de4a309722b3315439bb31d64ba3eebada841f2e2cee23b99df001434c912" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/docstring-parser/docstring_parser-0.17.0-py3-none-any.whl", hash = "sha256:cf2569abd23dce8099b300f9b4fa8191e9582dda731fd533daf54c4551658708" }, +] + +[[package]] +name = "docutils" +version = "0.22.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/docutils/docutils-0.22.4.tar.gz", hash = "sha256:4db53b1fde9abecbb74d91230d32ab626d94f6badfc575d6db9194a49df29968" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/docutils/docutils-0.22.4-py3-none-any.whl", hash = "sha256:d0013f540772d1420576855455d050a2180186c91c15779301ac2ccb3eeb68de" }, +] + +[[package]] +name = "einops" +version = "0.8.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/einops/einops-0.8.2.tar.gz", hash = "sha256:609da665570e5e265e27283aab09e7f279ade90c4f01bcfca111f3d3e13f2827" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/einops/einops-0.8.2-py3-none-any.whl", hash = "sha256:54058201ac7087911181bfec4af6091bb59380360f069276601256a76af08193" }, +] + +[[package]] +name = "etils" +version = "1.13.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/etils/etils-1.13.0.tar.gz", hash = "sha256:a5b60c71f95bcd2d43d4e9fb3dc3879120c1f60472bb5ce19f7a860b1d44f607" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/etils/etils-1.13.0-py3-none-any.whl", hash = "sha256:d9cd4f40fbe77ad6613b7348a18132cc511237b6c076dbb89105c0b520a4c6bb" }, +] + +[package.optional-dependencies] +edc = [ + { name = "typing-extensions" }, +] +enp = [ + { name = "einops" }, + { name = "numpy" }, + { name = "typing-extensions" }, +] +epath = [ + { name = "fsspec" }, + { name = "importlib-resources" }, + { name = "typing-extensions" }, + { name = "zipp" }, +] +epy = [ + { name = "typing-extensions" }, +] +etree = [ + { name = "absl-py" }, + { name = "einops" }, + { name = "numpy" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] + +[[package]] +name = "executing" +version = "2.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/executing/executing-2.2.1.tar.gz", hash = "sha256:3632cc370565f6648cc328b32435bd120a1e4ebb20c77e3fdde9a13cd1e533c4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/executing/executing-2.2.1-py2.py3-none-any.whl", hash = "sha256:760643d3452b4d777d295bb167ccc74c64a81df23fb5e08eff250c425a4b2017" }, +] + +[[package]] +name = "fastjsonschema" +version = "2.21.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fastjsonschema/fastjsonschema-2.21.2.tar.gz", hash = "sha256:b1eb43748041c880796cd077f1a07c3d94e93ae84bba5ed36800a33554ae05de" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fastjsonschema/fastjsonschema-2.21.2-py3-none-any.whl", hash = "sha256:1c797122d0a86c5cace2e54bf4e819c36223b552017172f32c5c024a6b77e463" }, +] + +[[package]] +name = "filelock" +version = "3.24.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/filelock/filelock-3.24.2.tar.gz", hash = "sha256:c22803117490f156e59fafce621f0550a7a853e2bbf4f87f112b11d469b6c81b" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/filelock/filelock-3.24.2-py3-none-any.whl", hash = "sha256:667d7dc0b7d1e1064dd5f8f8e80bdac157a6482e8d2e02cd16fd3b6b33bd6556" }, +] + +[[package]] +name = "flax" +version = "0.12.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "jax" }, + { name = "msgpack" }, + { name = "numpy" }, + { name = "optax" }, + { name = "orbax-checkpoint" }, + { name = "orbax-export" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "tensorstore" }, + { name = "treescope" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/flax/flax-0.12.4.tar.gz", hash = "sha256:5e924734a0595ddfa06a824568617e5440c7948e744772cbe6101b7ae06d66a9" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/flax/flax-0.12.4-py3-none-any.whl", hash = "sha256:cf90707923cb8a6d1a542039dd61e470c94bb11d7cac2349941a07f66605b19e" }, +] + +[[package]] +name = "fonttools" +version = "4.61.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1.tar.gz", hash = "sha256:6675329885c44657f826ef01d9e4fb33b9158e9d93c537d84ad8399539bc6f69" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c6604b735bb12fef8e0efd5578c9fb5d3d8532d5001ea13a19cddf295673ee09" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5ce02f38a754f207f2f06557523cd39a06438ba3aafc0639c477ac409fc64e37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:77efb033d8d7ff233385f30c62c7c79271c8885d5c9657d967ede124671bbdfb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:75c1a6dfac6abd407634420c93864a1e274ebc1c7531346d9254c0d8f6ca00f9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0de30bfe7745c0d1ffa2b0b7048fb7123ad0d71107e10ee090fa0b16b9452e87" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58b0ee0ab5b1fc9921eccfe11d1435added19d6494dde14e323f25ad2bc30c56" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-win32.whl", hash = "sha256:f79b168428351d11e10c5aeb61a74e1851ec221081299f4cf56036a95431c43a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp311-cp311-win_amd64.whl", hash = "sha256:fe2efccb324948a11dd09d22136fe2ac8a97d6c1347cf0b58a911dcd529f66b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f3cb4a569029b9f291f88aafc927dd53683757e640081ca8c412781ea144565e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:41a7170d042e8c0024703ed13b71893519a1a6d6e18e933e3ec7507a2c26a4b2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:10d88e55330e092940584774ee5e8a6971b01fc2f4d3466a1d6c158230880796" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:15acc09befd16a0fb8a8f62bc147e1a82817542d72184acca9ce6e0aeda9fa6d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e6bcdf33aec38d16508ce61fd81838f24c83c90a1d1b8c68982857038673d6b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:5fade934607a523614726119164ff621e8c30e8fa1ffffbbd358662056ba69f0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-win32.whl", hash = "sha256:75da8f28eff26defba42c52986de97b22106cb8f26515b7c22443ebc9c2d3261" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp312-cp312-win_amd64.whl", hash = "sha256:497c31ce314219888c0e2fce5ad9178ca83fe5230b01a5006726cdf3ac9f24d9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c56c488ab471628ff3bfa80964372fc13504ece601e0d97a78ee74126b2045c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc492779501fa723b04d0ab1f5be046797fee17d27700476edc7ee9ae535a61e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:64102ca87e84261419c3747a0d20f396eb024bdbeb04c2bfb37e2891f5fadcb5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4c1b526c8d3f615a7b1867f38a9410849c8f4aef078535742198e942fba0e9bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:41ed4b5ec103bd306bb68f81dc166e77409e5209443e5773cb4ed837bcc9b0d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b501c862d4901792adaec7c25b1ecc749e2662543f68bb194c42ba18d6eec98d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-win32.whl", hash = "sha256:4d7092bb38c53bbc78e9255a59158b150bcdc115a1e3b3ce0b5f267dc35dd63c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp313-cp313-win_amd64.whl", hash = "sha256:21e7c8d76f62ab13c9472ccf74515ca5b9a761d1bde3265152a6dc58700d895b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:fff4f534200a04b4a36e7ae3cb74493afe807b517a09e99cb4faa89a34ed6ecd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d9203500f7c63545b4ce3799319fe4d9feb1a1b89b28d3cb5abd11b9dd64147e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fa646ecec9528bef693415c79a86e733c70a4965dd938e9a226b0fc64c9d2e6c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:11f35ad7805edba3aac1a3710d104592df59f4b957e30108ae0ba6c10b11dd75" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b931ae8f62db78861b0ff1ac017851764602288575d65b8e8ff1963fed419063" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b148b56f5de675ee16d45e769e69f87623a4944f7443850bf9a9376e628a89d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-win32.whl", hash = "sha256:9b666a475a65f4e839d3d10473fad6d47e0a9db14a2f4a224029c5bfde58ad2c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314-win_amd64.whl", hash = "sha256:4f5686e1fe5fce75d82d93c47a438a25bf0d1319d2843a926f741140b2b16e0c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:e76ce097e3c57c4bcb67c5aa24a0ecdbd9f74ea9219997a707a4061fbe2707aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9cfef3ab326780c04d6646f68d4b4742aae222e8b8ea1d627c74e38afcbc9d91" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-manylinux1_x86_64.manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:a75c301f96db737e1c5ed5fd7d77d9c34466de16095a266509e13da09751bd19" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91669ccac46bbc1d09e9273546181919064e8df73488ea087dcac3e2968df9ba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c33ab3ca9d3ccd581d58e989d67554e42d8d4ded94ab3ade3508455fe70e65f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:664c5a68ec406f6b1547946683008576ef8b38275608e1cee6c061828171c118" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-win32.whl", hash = "sha256:aed04cabe26f30c1647ef0e8fbb207516fd40fe9472e9439695f5c6998e60ac5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-cp314-cp314t-win_amd64.whl", hash = "sha256:2180f14c141d2f0f3da43f3a81bc8aa4684860f6b0e6f9e165a4831f24e6a23b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fonttools/fonttools-4.61.1-py3-none-any.whl", hash = "sha256:17d2bf5d541add43822bcf0c43d7d847b160c9bb01d15d5007d84e2217aaa371" }, +] + +[[package]] +name = "frozenlist" +version = "1.8.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:09474e9831bc2b2199fad6da3c14c7b0fbdd377cce9d3d77131be28906cb7d84" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:17c883ab0ab67200b5f964d2b9ed6b00971917d5d8a92df149dc2c9779208ee9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:fa47e444b8ba08fffd1c18e8cdb9a75db1b6a27f17507522834ad13ed5922b93" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2552f44204b744fba866e573be4c1f9048d6a324dfe14475103fd51613eb1d1f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:957e7c38f250991e48a9a73e6423db1bb9dd14e722a10f6b8bb8e16a0f55f695" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:8585e3bb2cdea02fc88ffa245069c36555557ad3609e83be0ec71f54fd4abb52" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:edee74874ce20a373d62dc28b0b18b93f645633c2943fd90ee9d898550770581" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c9a63152fe95756b85f31186bddf42e4c02c6321207fd6601a1c89ebac4fe567" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b6db2185db9be0a04fecf2f241c70b63b1a242e2805be291855078f2b404dd6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:f4be2e3d8bc8aabd566f8d5b8ba7ecc09249d74ba3c9ed52e54dc23a293f0b92" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:c8d1634419f39ea6f5c427ea2f90ca85126b54b50837f31497f3bf38266e853d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:1a7fa382a4a223773ed64242dbe1c9c326ec09457e6b8428efb4118c685c3dfd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:11847b53d722050808926e785df837353bd4d75f1d494377e59b23594d834967" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-win32.whl", hash = "sha256:27c6e8077956cf73eadd514be8fb04d77fc946a7fe9f7fe167648b0b9085cc25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:ac913f8403b36a2c8610bbfd25b8013488533e71e62b4b4adce9c86c8cea905b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp311-cp311-win_arm64.whl", hash = "sha256:d4d3214a0f8394edfa3e303136d0575eece0745ff2b47bd2cb2e66dd92d4351a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/frozenlist/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d" }, +] + +[[package]] +name = "fsspec" +version = "2025.10.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fsspec/fsspec-2025.10.0.tar.gz", hash = "sha256:b6789427626f068f9a83ca4e8a3cc050850b6c0f71f99ddb4f542b8266a26a59" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/fsspec/fsspec-2025.10.0-py3-none-any.whl", hash = "sha256:7c7712353ae7d875407f97715f0e1ffcc21e33d5b24556cb1e090ae9409ec61d" }, +] + +[package.optional-dependencies] +http = [ + { name = "aiohttp" }, +] + +[[package]] +name = "gitdb" +version = "4.0.12" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "smmap" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/gitdb/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/gitdb/gitdb-4.0.12-py3-none-any.whl", hash = "sha256:67073e15955400952c6565cc3e707c554a4eea2e428946f7a4c162fab9bd9bcf" }, +] + +[[package]] +name = "gitpython" +version = "3.1.46" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "gitdb" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/gitpython/gitpython-3.1.46.tar.gz", hash = "sha256:400124c7d0ef4ea03f7310ac2fbf7151e09ff97f2a3288d64a440c584a29c37f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/gitpython/gitpython-3.1.46-py3-none-any.whl", hash = "sha256:79812ed143d9d25b6d176a10bb511de0f9c67b1fa641d82097b0ab90398a2058" }, +] + +[[package]] +name = "google-metrax" +version = "0.2.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "clu" }, + { name = "flax" }, + { name = "jax" }, + { name = "numpy" }, + { name = "tensorboardx" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/google-metrax/google_metrax-0.2.4.tar.gz", hash = "sha256:5f8572f4cf612ded3b81b75dffb1f296e12e7d8cfae9d2237e2561357c5c4dac" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/google-metrax/google_metrax-0.2.4-py3-none-any.whl", hash = "sha256:98233aed2d9dfd98d510b8df16550d935b8aa9d818eef5017d5d301b4ba4f5f5" }, +] + +[[package]] +name = "google-tunix" +version = "0.1.6" +source = { editable = "." } +dependencies = [ + { name = "datasets" }, + { name = "flax" }, + { name = "fsspec" }, + { name = "google-metrax" }, + { name = "grain" }, + { name = "hf-transfer" }, + { name = "huggingface-hub" }, + { name = "jaxtyping" }, + { name = "jinja2" }, + { name = "kagglehub" }, + { name = "numba" }, + { name = "omegaconf" }, + { name = "pylatexenc" }, + { name = "python-dotenv" }, + { name = "qwix" }, + { name = "sentencepiece" }, + { name = "sympy" }, + { name = "tenacity" }, + { name = "tensorflow-datasets" }, + { name = "tqdm" }, + { name = "transformers" }, +] + +[package.optional-dependencies] +docs = [ + { name = "ipython" }, + { name = "matplotlib" }, + { name = "myst-nb" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, + { name = "sphinx-autodoc-typehints", version = "3.6.1", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx-autodoc-typehints", version = "3.6.2", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, + { name = "sphinx-book-theme" }, + { name = "sphinx-collections" }, + { name = "sphinx-contributors" }, + { name = "sphinx-gallery" }, +] +prod = [ + { name = "jax", extra = ["tpu"] }, +] + +[package.metadata] +requires-dist = [ + { name = "datasets" }, + { name = "flax", specifier = ">=0.11.1" }, + { name = "fsspec" }, + { name = "google-metrax", specifier = ">=0.2.3" }, + { name = "grain" }, + { name = "hf-transfer" }, + { name = "huggingface-hub" }, + { name = "ipython", marker = "extra == 'docs'", specifier = ">=8.8.0" }, + { name = "jax", extras = ["tpu"], marker = "extra == 'prod'", specifier = ">=0.6.0,!=0.7.2,<=0.8.1" }, + { name = "jaxtyping" }, + { name = "jinja2" }, + { name = "kagglehub" }, + { name = "matplotlib", marker = "extra == 'docs'", specifier = ">=3.10.0" }, + { name = "myst-nb", marker = "extra == 'docs'", specifier = ">=1.3.0" }, + { name = "numba" }, + { name = "omegaconf" }, + { name = "pylatexenc" }, + { name = "python-dotenv" }, + { name = "qwix" }, + { name = "sentencepiece" }, + { name = "sphinx", marker = "extra == 'docs'", specifier = ">=8.2.3" }, + { name = "sphinx-autodoc-typehints", marker = "extra == 'docs'" }, + { name = "sphinx-book-theme", marker = "extra == 'docs'", specifier = ">=1.1.4" }, + { name = "sphinx-collections", marker = "extra == 'docs'", specifier = ">=0.0.1" }, + { name = "sphinx-contributors", marker = "extra == 'docs'" }, + { name = "sphinx-gallery", marker = "extra == 'docs'", specifier = ">=0.19.0" }, + { name = "sympy" }, + { name = "tenacity" }, + { name = "tensorflow-datasets" }, + { name = "tqdm" }, + { name = "transformers", specifier = "<=4.57.1" }, +] +provides-extras = ["docs", "prod", "dev"] + +[[package]] +name = "googleapis-common-protos" +version = "1.72.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "protobuf" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/googleapis-common-protos/googleapis_common_protos-1.72.0.tar.gz", hash = "sha256:e55a601c1b32b52d7a3e65f43563e2aa61bcd737998ee672ac9b951cd49319f5" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/googleapis-common-protos/googleapis_common_protos-1.72.0-py3-none-any.whl", hash = "sha256:4299c5a82d5ae1a9702ada957347726b167f9f8d1fc352477702a1e851ff4038" }, +] + +[[package]] +name = "grain" +version = "0.2.15" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "array-record", marker = "sys_platform != 'win32'" }, + { name = "cloudpickle" }, + { name = "etils", extra = ["epath", "epy"] }, + { name = "numpy" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:63b90d0719a97c25a8b30057e224436dfaf3ba975e5baadaf8b3417235a09631" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:60f5ded548e58251af4a7429779c472cdb5ab716a448c32e500e6eb79957c5e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcac68693f539f5421560250fe906c62b00daeb58a28a56ac7b8d9dad2ba7483" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp311-cp311-win_amd64.whl", hash = "sha256:7e8d7114f079cb3cfa9953e699cb44a44b179e9fb2ca4f61e8b7ac8ca90c33ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:149b195ebd2a2e06e00019af5e83d7d6fef18b6149471ba0baaf6bdfac1a0558" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9bbf2c57a92fae5d883e04bda35d373202f026cbd9952b9bdd831bda2c60ddd7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fecc1553e539b946ed7f3508261f98309d07f899c06af1954186cf7d6a4613b2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp312-cp312-win_amd64.whl", hash = "sha256:cc58394bdddd5db1b1e1e2878899a1e78014f60046ead82415011eca36475287" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:df0c4af1442f71effc80a5b44bb33fe5aabb7b3d82d5a3ac035ae40431935c77" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4766dc1355448cf7b3bdd3cc4f4639bc3433c66c5502954380b9a8f4c2b3fc94" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ae2635e3bd18b77a7add7152ee91b22aba553fa44a066aefa009d1b923ade4f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp313-cp313-win_amd64.whl", hash = "sha256:9d3cc6edfa4d0de341de0d03ba4a8612d94639bed97fe63af3951db8305c96c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:36e1413c275741712918e528f3f65ca254ce51d60160a2b9558c020147f38e98" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fedbb410486890c6e410c8d78934097b2755aa2363fbd6137b920ea5be104530" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e1a5e20ffc29391c48b5d8f818742f4ecce957fe59ccff971c139721d31a0bf4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/grain/grain-0.2.15-cp314-cp314-win_amd64.whl", hash = "sha256:d57493fa4361316755cb0564f87e62d1da1dedae4eed53acf179ec029668dee5" }, +] + +[[package]] +name = "greenlet" +version = "3.3.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1.tar.gz", hash = "sha256:41848f3230b58c08bb43dee542e74a2a2e34d3c59dc3076cec9151aeeedcae98" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5fd23b9bc6d37b563211c6abbb1b3cab27db385a4449af5c32e932f93017080c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:09f51496a0bfbaa9d74d36a52d2580d1ef5ed4fdfcff0a73730abfbbbe1403dd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb0feb07fe6e6a74615ee62a880007d976cf739b6669cce95daa7373d4fc69c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:67ea3fc73c8cd92f42467a72b75e8f05ed51a0e9b1d15398c913416f2dafd49f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:39eda9ba259cc9801da05351eaa8576e9aa83eb9411e8f0c299e05d712a210f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:e2e7e882f83149f0a71ac822ebf156d902e7a5d22c9045e3e0d1daf59cee2cc9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:80aa4d79eb5564f2e0a6144fcc744b5a37c56c4a92d60920720e99210d88db0f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:32e4ca9777c5addcbf42ff3915d99030d8e00173a56f80001fb3875998fe410b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp311-cp311-win_arm64.whl", hash = "sha256:da19609432f353fed186cc1b85e9440db93d489f198b4bdf42ae19cc9d9ac9b4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:7e806ca53acf6d15a888405880766ec84721aa4181261cd11a457dfe9a7a4975" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d842c94b9155f1c9b3058036c24ffb8ff78b428414a19792b2380be9cecf4f36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:20fedaadd422fa02695f82093f9a98bad3dab5fcda793c658b945fcde2ab27ba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c620051669fd04ac6b60ebc70478210119c56e2d5d5df848baec4312e260e4ca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14194f5f4305800ff329cbf02c5fcc88f01886cadd29941b807668a45f0d2336" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7b2fe4150a0cf59f847a67db8c155ac36aed89080a6a639e9f16df5d6c6096f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:49f4ad195d45f4a66a0eb9c1ba4832bb380570d361912fa3554746830d332149" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:cc98b9c4e4870fa983436afa999d4eb16b12872fab7071423d5262fa7120d57a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp312-cp312-win_arm64.whl", hash = "sha256:bfb2d1763d777de5ee495c85309460f6fd8146e50ec9d0ae0183dbf6f0a829d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:7ab327905cabb0622adca5971e488064e35115430cec2c35a50fd36e72a315b3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:65be2f026ca6a176f88fb935ee23c18333ccea97048076aef4db1ef5bc0713ac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7a3ae05b3d225b4155bda56b072ceb09d05e974bc74be6c3fc15463cf69f33fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:12184c61e5d64268a160226fb4818af4df02cfead8379d7f8b99a56c3a54ff3e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6423481193bbbe871313de5fd06a082f2649e7ce6e08015d2a76c1e9186ca5b3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:33a956fe78bbbda82bfc95e128d61129b32d66bcf0a20a1f0c08aa4839ffa951" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b065d3284be43728dd280f6f9a13990b56470b81be20375a207cdc814a983f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:27289986f4e5b0edec7b5a91063c109f0276abb09a7e9bdab08437525977c946" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp313-cp313-win_arm64.whl", hash = "sha256:2f080e028001c5273e0b42690eaf359aeef9cb1389da0f171ea51a5dc3c7608d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:bd59acd8529b372775cd0fcbc5f420ae20681c5b045ce25bd453ed8455ab99b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b31c05dd84ef6871dd47120386aed35323c944d86c3d91a17c4b8d23df62f15b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:02925a0bfffc41e542c70aa14c7eda3593e4d7e274bfcccca1827e6c0875902e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3e0f3878ca3a3ff63ab4ea478585942b53df66ddde327b59ecb191b19dbbd62d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:34a729e2e4e4ffe9ae2408d5ecaf12f944853f40ad724929b7585bca808a9d6f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:aec9ab04e82918e623415947921dea15851b152b822661cce3f8e4393c3df683" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:71c767cf281a80d02b6c1bdc41c9468e1f5a494fb11bc8688c360524e273d7b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-win_amd64.whl", hash = "sha256:96aff77af063b607f2489473484e39a0bbae730f2ea90c9e5606c9b73c44174a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314-win_arm64.whl", hash = "sha256:b066e8b50e28b503f604fa538adc764a638b38cf8e81e025011d26e8a627fa79" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-macosx_11_0_universal2.whl", hash = "sha256:3e63252943c921b90abb035ebe9de832c436401d9c45f262d80e2d06cc659242" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76e39058e68eb125de10c92524573924e827927df5d3891fbc97bd55764a8774" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c9f9d5e7a9310b7a2f416dd13d2e3fd8b42d803968ea580b7c0f322ccb389b97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b9721549a95db96689458a1e0ae32412ca18776ed004463df3a9299c1b257ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:92497c78adf3ac703b57f1e3813c2d874f27f71a178f9ea5887855da413cd6d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ed6b402bc74d6557a705e197d47f9063733091ed6357b3de33619d8a8d93ac53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:59913f1e5ada20fde795ba906916aea25d442abcc0593fba7e26c92b7ad76249" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/greenlet/greenlet-3.3.1-cp314-cp314t-win_amd64.whl", hash = "sha256:301860987846c24cb8964bdec0e31a96ad4a2a801b41b4ef40963c1b44f33451" }, +] + +[[package]] +name = "h11" +version = "0.16.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/h11/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/h11/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86" }, +] + +[[package]] +name = "hf-transfer" +version = "0.1.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9.tar.gz", hash = "sha256:035572865dab29d17e783fbf1e84cf1cb24f3fcf8f1b17db1cfc7fdf139f02bf" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:6e94e8822da79573c9b6ae4d6b2f847c59a7a06c5327d7db20751b68538dc4f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ebc4ab9023414880c8b1d3c38174d1c9989eb5022d37e814fa91a3060123eb0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8674026f21ed369aa2a0a4b46000aca850fc44cd2b54af33a172ce5325b4fc82" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:3a736dfbb2c84f5a2c975478ad200c0c8bfcb58a25a35db402678fb87ce17fa4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:504b8427fd785dd8546d53b9fafe6e436bd7a3adf76b9dce556507650a7b4567" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:2c7fc1b85f4d0f76e452765d7648c9f4bfd0aedb9ced2ae1ebfece2d8cfaf8e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d991376f0eac70a60f0cbc95602aa708a6f7c8617f28b4945c1431d67b8e3c8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:e6ac4eddcd99575ed3735ed911ddf9d1697e2bd13aa3f0ad7e3904dd4863842e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:57fd9880da1ee0f47250f735f791fab788f0aa1ee36afc49f761349869c8b4d9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:5d561f0520f493c66b016d99ceabe69c23289aa90be38dd802d2aef279f15751" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:a5b366d34cd449fe9b20ef25941e6eef0460a2f74e7389f02e673e1f88ebd538" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:e66acf91df4a8b72f60223059df3003062a5ae111757187ed1a06750a30e911b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:8669dbcc7a3e2e8d61d42cd24da9c50d57770bd74b445c65123291ca842a7e7a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8fd0167c4407a3bc4cdd0307e65ada2294ec04f1813d8a69a5243e379b22e9d8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ee8b10afedcb75f71091bcc197c526a6ebf5c58bbbadb34fdeee6160f55f619f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5828057e313de59300dd1abb489444bc452efe3f479d3c55b31a8f680936ba42" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fc6bd19e1cc177c66bdef15ef8636ad3bde79d5a4f608c158021153b4573509d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdca9bfb89e6f8f281890cc61a8aff2d3cecaff7e1a4d275574d96ca70098557" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:89a23f58b7b7effbc047b8ca286f131b17728c99a9f972723323003ffd1bb916" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:dc7fff1345980d6c0ebb92c811d24afa4b98b3e07ed070c8e38cc91fd80478c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:1a6bd16c667ebe89a069ca163060127a794fa3a3525292c900b8c8cc47985b0d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:d2fde99d502093ade3ab1b53f80da18480e9902aa960dab7f74fb1b9e5bc5746" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-win32.whl", hash = "sha256:435cc3cdc8524ce57b074032b8fd76eed70a4224d2091232fa6a8cef8fd6803e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-transfer/hf_transfer-0.1.9-cp38-abi3-win_amd64.whl", hash = "sha256:16f208fc678911c37e11aa7b586bc66a37d02e636208f18b6bc53d29b5df40ad" }, +] + +[[package]] +name = "hf-xet" +version = "1.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1.tar.gz", hash = "sha256:6c7a48d40b25f06f7f1b0fdd96c6f9d222dd4d0c833990684723eb77163b7372" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:d9b8118b8b171f0482a61d40a473335857d2b85fcceca499fe16db887e5bf0fb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:29c0603f7b27d58dc35b4f859cf62a8d905782db4e3cd0253cb45b3225e6c6f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ad56e0f6cfcdde30c436aee3a2adfd66d7432b0e1598353321c644576b97623a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:29cc367533e338f2a0c65d186882c05e6e6841f5c591562c629de652d5ec219e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:6df5382f854cedd0cf78bffb2d93ffeb877717fe4ab0871735dbeb77a02c3c3c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:efd65ead9913c199031250d154c242a6ce3876e2ac725155bb66483b610e799e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:72fc277b3655861121dbbdd3ac0315263fe5de63f6a844dd395245dcb66928e6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:cc3902fa877c15f36ee149897f54cd97340aed602e4544bc1e80151b47635edc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:5d66cf732d3d46f3b12f1d14d6f5c639433dd332af8e851d148a80bcfcb56f25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:0429f6de40d2d6d4e04f412e3f9074fd5a208f9145b5247a2ea66c689b1a5768" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2b898f9d106f0ef83bd2f73e973e3e702d1368a0404315fc8ad64156434a443b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b45cfc180275f69ecc570ef98946752fbd9424ddc9bca895942fef3f0b85f3a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:bf957da3fe3571e2f161b98193065baa54c9eb8670b914daccb60aa1c9ee94a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cc0fde31706c0626beb5430665512e53da23004c6c020c80256be057b6248255" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:7ea0eb9dab2276fc2e502dc8c095c0c2b00cf89ae3d7899b6878dfa5ea1c1464" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:ac0b51005cf12e7f88654d4e127f1b8d2378a2db575782fc3ea25d4c0e7e5c49" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0b0742e1258335686c82cbda57d6587081c25f9e004b135de485b76166c3f172" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:1cae780544f0d8849174e82047bd7a8c1d9e14b7c13dce99b1462574bedf3358" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ce3a09c77f1ba29fedb2b1f397948d8a237a8062afa946821811b39abb9903b4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e722352e5e9414030b44eacce598f840aab8b5d5ea36ea66a6c9121e52a9455b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:3214bae661c600232ce71bff88d22b6cb81f669be4e98ce4b57114c135fd208d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:397c6dadecf1303d084b675efa4afd920229ccc13b84bfc095f48dfd508f464e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:885ac1975b064cf3919650f5e5efdddf72a4ebe3e1f6fe027a4a9a319e43a17b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/hf-xet/hf_xet-1.2.1-cp37-abi3-win_amd64.whl", hash = "sha256:c76704cdda11cac957519dc8cb868eb103e561e9bfea284c8678e7d975bb4369" }, +] + +[[package]] +name = "httpcore" +version = "1.0.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "certifi" }, + { name = "h11" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/httpcore/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/httpcore/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55" }, +] + +[[package]] +name = "httpx" +version = "0.28.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/httpx/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/httpx/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad" }, +] + +[[package]] +name = "huggingface-hub" +version = "0.36.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet", marker = "platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'arm64' or platform_machine == 'x86_64'" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/huggingface-hub/huggingface_hub-0.36.2.tar.gz", hash = "sha256:1934304d2fb224f8afa3b87007d58501acfda9215b334eed53072dd5e815ff7a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/huggingface-hub/huggingface_hub-0.36.2-py3-none-any.whl", hash = "sha256:48f0c8eac16145dfce371e9d2d7772854a4f591bcb56c9cf548accf531d54270" }, +] + +[[package]] +name = "humanize" +version = "4.15.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/humanize/humanize-4.15.0.tar.gz", hash = "sha256:1dd098483eb1c7ee8e32eb2e99ad1910baefa4b75c3aff3a82f4d78688993b10" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/humanize/humanize-4.15.0-py3-none-any.whl", hash = "sha256:b1186eb9f5a9749cd9cb8565aee77919dd7c8d076161cf44d70e59e3301e1769" }, +] + +[[package]] +name = "idna" +version = "3.11" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/idna/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/idna/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea" }, +] + +[[package]] +name = "imagesize" +version = "1.4.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/imagesize/imagesize-1.4.1.tar.gz", hash = "sha256:69150444affb9cb0d5cc5a92b3676f0b2fb7cd9ae39e947a5e11a36b4497cd4a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/imagesize/imagesize-1.4.1-py2.py3-none-any.whl", hash = "sha256:0d8d18d08f840c19d0ee7ca1fd82490fdc3729b7ac93f49870406ddde8ef8d8b" }, +] + +[[package]] +name = "immutabledict" +version = "4.3.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/immutabledict/immutabledict-4.3.1.tar.gz", hash = "sha256:f844a669106cfdc73f47b1a9da003782fb17dc955a54c80972e0d93d1c63c514" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/immutabledict/immutabledict-4.3.1-py3-none-any.whl", hash = "sha256:c9facdc0ff30fdb8e35bd16532026cac472a549e182c94fa201b51b25e4bf7bf" }, +] + +[[package]] +name = "importlib-metadata" +version = "8.7.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "zipp" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/importlib-metadata/importlib_metadata-8.7.1.tar.gz", hash = "sha256:49fef1ae6440c182052f407c8d34a68f72efc36db9ca90dc0113398f2fdde8bb" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/importlib-metadata/importlib_metadata-8.7.1-py3-none-any.whl", hash = "sha256:5a1f80bf1daa489495071efbb095d75a634cf28a8bc299581244063b53176151" }, +] + +[[package]] +name = "importlib-resources" +version = "6.5.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/importlib-resources/importlib_resources-6.5.2.tar.gz", hash = "sha256:185f87adef5bcc288449d98fb4fba07cea78bc036455dd44c5fc4a2fe78fed2c" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/importlib-resources/importlib_resources-6.5.2-py3-none-any.whl", hash = "sha256:789cfdc3ed28c78b67a06acb8126751ced69a3d5f79c095a98298cd8a760ccec" }, +] + +[[package]] +name = "ipykernel" +version = "7.2.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "appnope", marker = "sys_platform == 'darwin'" }, + { name = "comm" }, + { name = "debugpy" }, + { name = "ipython" }, + { 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://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipykernel/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipykernel/ipykernel-7.2.0-py3-none-any.whl", hash = "sha256:3bbd4420d2b3cc105cbdf3756bfc04500b1e52f090a90716851f3916c62e1661" }, +] + +[[package]] +name = "ipython" +version = "9.10.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect", marker = "sys_platform != 'emscripten' and sys_platform != 'win32'" }, + { name = "prompt-toolkit" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, + { name = "typing-extensions", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipython/ipython-9.10.0.tar.gz", hash = "sha256:cd9e656be97618a0676d058134cd44e6dc7012c0e5cb36a9ce96a8c904adaf77" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipython/ipython-9.10.0-py3-none-any.whl", hash = "sha256:c6ab68cc23bba8c7e18e9b932797014cc61ea7fd6f19de180ab9ba73e65ee58d" }, +] + +[[package]] +name = "ipython-pygments-lexers" +version = "1.1.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "pygments" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipython-pygments-lexers/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ipython-pygments-lexers/ipython_pygments_lexers-1.1.1-py3-none-any.whl", hash = "sha256:a9462224a505ade19a605f71f8fa63c2048833ce50abc86768a0d81d876dc81c" }, +] + +[[package]] +name = "jax" +version = "0.8.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "jaxlib" }, + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "opt-einsum" }, + { name = "scipy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jax/jax-0.8.1.tar.gz", hash = "sha256:e53f67b15315f5e154851a7fd77a192b59c6c75b3f7ac56e214296765391cca7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jax/jax-0.8.1-py3-none-any.whl", hash = "sha256:4cbdc5548f3095cdd69d38e4337950b2fc1f250a740a0234d190e4a319077564" }, +] + +[package.optional-dependencies] +tpu = [ + { name = "jaxlib" }, + { name = "libtpu" }, + { name = "requests" }, +] + +[[package]] +name = "jaxlib" +version = "0.8.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "scipy" }, +] +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:865add56139883405f3f15c9b0de6a64ab8f4aa549dff196b72dbc86be6ccc1f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp311-cp311-manylinux_2_27_aarch64.whl", hash = "sha256:ff32b6320d729131efaf22939825b52d75957c84c32af2b0b1bdb33cf27ba75f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp311-cp311-manylinux_2_27_x86_64.whl", hash = "sha256:22f489fb5c8be0da7be5e4957a10936b3760a169668f8b25c5d09c51c3ef47f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:c14c8c19a7eb694aa14092b6d2fffb9d2bdd8a603b63d6f26fbeaf129c204f9f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:88bde0f535eeea6689e0cd57d40b7660d5206ac95c7d42e09562a109b963a49f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp312-cp312-manylinux_2_27_aarch64.whl", hash = "sha256:bed1e94ae8c7c16bca4476d8d7f582f0d1a102a4e69c3a9bd2069a0dc42274a9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp312-cp312-manylinux_2_27_x86_64.whl", hash = "sha256:af4924189fc53b69237715b56ebcbfc71bb91ca16184143dcef0d430c8173de6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:24ec3f3a9c45d6de060020dc94c444d69e18099fab927ea3979ff8cedf0ed2c9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a0349f6e8179dc897d33aeb90ec66b4a8041330fbbba8d071dc6167cd2271539" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313-manylinux_2_27_aarch64.whl", hash = "sha256:bd697c171ace1e2e9d6ed910a78f385b3c4095cee290b0255aa58848f2acdeab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313-manylinux_2_27_x86_64.whl", hash = "sha256:d245bd6a279c72ca5f796df84cdd64d7c9c8abc4b8d89adf4acf45898dab958b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313-win_amd64.whl", hash = "sha256:8e118e1fbe714f37a94ba26777c17faab7dca4a33646a3d98cd1d99673bbd6b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4933298fcfb07a5aa2d1fed21c111d07cea50e6f180dba2cdb5463c13fb98f2f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313t-manylinux_2_27_aarch64.whl", hash = "sha256:f2f11491b077d05249d63813e811401194a41edc8e9cc60af8f4b554057cfad0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp313-cp313t-manylinux_2_27_x86_64.whl", hash = "sha256:7a5d381fad89622750fae29fab83c0847e2931ad8d6a34dc13b28fc4d67f75a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:90e48973f8dbded7edc8728be84c01ae00412190187fb06622abfa4edd42c0a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314-manylinux_2_27_aarch64.whl", hash = "sha256:1a4001ed3ba9ed5a812da1b16f52eebb5d473a4480c1523828c7bd3dae8d1375" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314-manylinux_2_27_x86_64.whl", hash = "sha256:fdbbf2336c08bbf8f30548e204c8c9d77f8b2a3a5b7fc7985749246feb8852b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314-win_amd64.whl", hash = "sha256:63fc25c4b5d03256798796a024125e29bcf254acc3eae5dc3239d1c30b86b866" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:92c41c9b9862c08521eb90515a7c5bcc840c6d30f86230cebf94aea2d6a0af81" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314t-manylinux_2_27_aarch64.whl", hash = "sha256:1bc76edec2bc74a7adb5e29329ece51a67c57cd011a06d55d07da62fbabe3389" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxlib/jaxlib-0.8.1-cp314-cp314t-manylinux_2_27_x86_64.whl", hash = "sha256:117f2fe2c19479e560ad85a3ef2fcc0b1d24816456f0d039f865c2acbab63b5a" }, +] + +[[package]] +name = "jaxtyping" +version = "0.3.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "wadler-lindig" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxtyping/jaxtyping-0.3.9.tar.gz", hash = "sha256:f8c02d1b623d5f1b6665d4f3ddaec675d70004f16a792102c2fc51264190951d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jaxtyping/jaxtyping-0.3.9-py3-none-any.whl", hash = "sha256:a00557a9d616eff157491f06ed2e21ed94886fad3832399273eb912b345da378" }, +] + +[[package]] +name = "jedi" +version = "0.19.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "parso" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jedi/jedi-0.19.2.tar.gz", hash = "sha256:4770dc3de41bde3966b02eb84fbcf557fb33cce26ad23da12c742fb50ecb11f0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jedi/jedi-0.19.2-py2.py3-none-any.whl", hash = "sha256:a8ef22bde8490f57fe5c7681a3c83cb58874daf72b4784de3cce5b6ef6edb5b9" }, +] + +[[package]] +name = "jinja2" +version = "3.1.6" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "markupsafe" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jinja2/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jinja2/jinja2-3.1.6-py3-none-any.whl", hash = "sha256:85ece4451f492d0c13c5dd7c13a64681a86afae63a5f347908daf103ce6d2f67" }, +] + +[[package]] +name = "jsonschema" +version = "4.26.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jsonschema/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jsonschema/jsonschema-4.26.0-py3-none-any.whl", hash = "sha256:d489f15263b8d200f8387e64b4c3a75f06629559fb73deb8fdfb525f2dab50ce" }, +] + +[[package]] +name = "jsonschema-specifications" +version = "2025.9.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "referencing" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jsonschema-specifications/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jsonschema-specifications/jsonschema_specifications-2025.9.1-py3-none-any.whl", hash = "sha256:98802fee3a11ee76ecaca44429fda8a41bff98b00a0f2838151b113f210cc6fe" }, +] + +[[package]] +name = "jupyter-cache" +version = "1.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "attrs" }, + { name = "click" }, + { name = "importlib-metadata" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sqlalchemy" }, + { name = "tabulate" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-cache/jupyter_cache-1.0.1.tar.gz", hash = "sha256:16e808eb19e3fb67a223db906e131ea6e01f03aa27f49a7214ce6a5fec186fb9" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-cache/jupyter_cache-1.0.1-py3-none-any.whl", hash = "sha256:9c3cafd825ba7da8b5830485343091143dff903e4d8c69db9349b728b140abf6" }, +] + +[[package]] +name = "jupyter-client" +version = "8.8.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-client/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-client/jupyter_client-8.8.0-py3-none-any.whl", hash = "sha256:f93a5b99c5e23a507b773d3a1136bd6e16c67883ccdbd9a829b0bbdb98cd7d7a" }, +] + +[[package]] +name = "jupyter-core" +version = "5.9.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "platformdirs" }, + { name = "traitlets" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-core/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/jupyter-core/jupyter_core-5.9.1-py3-none-any.whl", hash = "sha256:ebf87fdc6073d142e114c72c9e29a9d7ca03fad818c5d300ce2adc1fb0743407" }, +] + +[[package]] +name = "kagglehub" +version = "1.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "kagglesdk" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "tqdm" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kagglehub/kagglehub-1.0.0.tar.gz", hash = "sha256:21dc25d0279e2071f8b97cd9e1393d003ea5e054ea48f1e8139a39e4771e9a8d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kagglehub/kagglehub-1.0.0-py3-none-any.whl", hash = "sha256:9397f0c6af04cdefa6fa8734c31b42863e8741aad5832c6f3af52f1ecf8fe509" }, +] + +[[package]] +name = "kagglesdk" +version = "0.1.15" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "protobuf" }, + { name = "requests" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kagglesdk/kagglesdk-0.1.15.tar.gz", hash = "sha256:a26ecc64b1334b5a4c5cadd076bdeb503c04eab51c10d7cac2ff04959c9baba0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kagglesdk/kagglesdk-0.1.15-py3-none-any.whl", hash = "sha256:f7b49e795d5d0d72ba3612e6e6a1f39296978dbc7cd44d2015502e8bb1039738" }, +] + +[[package]] +name = "kiwisolver" +version = "1.4.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9.tar.gz", hash = "sha256:c3b22c26c6fd6811b0ae8363b95ca8ce4ea3c202d3d0975b2914310ceb1bcc4d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:eb14a5da6dc7642b0f3a18f13654847cd8b7a2550e2645a5bda677862b03ba16" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:39a219e1c81ae3b103643d2aedb90f1ef22650deb266ff12a19e7773f3e5f089" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2405a7d98604b87f3fc28b1716783534b1b4b8510d8142adca34ee0bc3c87543" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:dc1ae486f9abcef254b5618dfb4113dd49f94c68e3e027d03cf0143f3f772b61" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8a1f570ce4d62d718dce3f179ee78dac3b545ac16c0c04bb363b7607a949c0d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb27e7b78d716c591e88e0a09a2139c6577865d7f2e152488c2cc6257f460872" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:15163165efc2f627eb9687ea5f3a28137217d217ac4024893d753f46bce9de26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:bdee92c56a71d2b24c33a7d4c2856bd6419d017e08caa7802d2963870e315028" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:412f287c55a6f54b0650bd9b6dce5aceddb95864a1a90c87af16979d37c89771" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:2c93f00dcba2eea70af2be5f11a830a742fe6b579a1d4e00f47760ef13be247a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f117e1a089d9411663a3207ba874f31be9ac8eaa5b533787024dc07aeb74f464" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-win_amd64.whl", hash = "sha256:be6a04e6c79819c9a8c2373317d19a96048e5a3f90bec587787e86a1153883c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp311-cp311-win_arm64.whl", hash = "sha256:0ae37737256ba2de764ddc12aed4956460277f00c4996d51a197e72f62f5eec7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:ac5a486ac389dddcc5bef4f365b6ae3ffff2c433324fb38dd35e3fab7c957999" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f2ba92255faa7309d06fe44c3a4a97efe1c8d640c2a79a5ef728b685762a6fd2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4a2899935e724dd1074cb568ce7ac0dce28b2cd6ab539c8e001a8578eb106d14" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f6008a4919fdbc0b0097089f67a1eb55d950ed7e90ce2cc3e640abadd2757a04" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:67bb8b474b4181770f926f7b7d2f8c0248cbcb78b660fdd41a47054b28d2a752" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2327a4a30d3ee07d2fbe2e7933e8a37c591663b96ce42a00bc67461a87d7df77" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:7a08b491ec91b1d5053ac177afe5290adacf1f0f6307d771ccac5de30592d198" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d8fc5c867c22b828001b6a38d2eaeb88160bf5783c6cb4a5e440efc981ce286d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:3b3115b2581ea35bb6d1f24a4c90af37e5d9b49dcff267eeed14c3893c5b86ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:858e4c22fb075920b96a291928cb7dea5644e94c0ee4fcd5af7e865655e4ccf2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ed0fecd28cc62c54b262e3736f8bb2512d8dcfdc2bcf08be5f47f96bf405b145" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-win_amd64.whl", hash = "sha256:f68208a520c3d86ea51acf688a3e3002615a7f0238002cccc17affecc86a8a54" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp312-cp312-win_arm64.whl", hash = "sha256:2c1a4f57df73965f3f14df20b80ee29e6a7930a57d2d9e8491a25f676e197c60" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a5d0432ccf1c7ab14f9949eec60c5d1f924f17c037e9f8b33352fa05799359b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efb3a45b35622bb6c16dbfab491a8f5a391fe0e9d45ef32f4df85658232ca0e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1a12cf6398e8a0a001a059747a1cbf24705e18fe413bc22de7b3d15c67cffe3f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b67e6efbf68e077dd71d1a6b37e43e1a99d0bff1a3d51867d45ee8908b931098" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5656aa670507437af0207645273ccdfee4f14bacd7f7c67a4306d0dcaeaf6eed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:bfc08add558155345129c7803b3671cf195e6a56e7a12f3dde7c57d9b417f525" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:40092754720b174e6ccf9e845d0d8c7d8e12c3d71e7fc35f55f3813e96376f78" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:497d05f29a1300d14e02e6441cf0f5ee81c1ff5a304b0d9fb77423974684e08b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bdd1a81a1860476eb41ac4bc1e07b3f07259e6d55bbf739b79c8aaedcf512799" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:e6b93f13371d341afee3be9f7c5964e3fe61d5fa30f6a30eb49856935dfe4fc3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d75aa530ccfaa593da12834b86a0724f58bff12706659baa9227c2ccaa06264c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-win_amd64.whl", hash = "sha256:dd0a578400839256df88c16abddf9ba14813ec5f21362e1fe65022e00c883d4d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313-win_arm64.whl", hash = "sha256:d4188e73af84ca82468f09cadc5ac4db578109e52acb4518d8154698d3a87ca2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:5a0f2724dfd4e3b3ac5a82436a8e6fd16baa7d507117e4279b660fe8ca38a3a1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:1b11d6a633e4ed84fc0ddafd4ebfd8ea49b3f25082c04ad12b8315c11d504dc1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:61874cdb0a36016354853593cffc38e56fc9ca5aa97d2c05d3dcf6922cd55a11" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:60c439763a969a6af93b4881db0eed8fadf93ee98e18cbc35bc8da868d0c4f0c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92a2f997387a1b79a75e7803aa7ded2cfbe2823852ccf1ba3bcf613b62ae3197" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a31d512c812daea6d8b3be3b2bfcbeb091dbb09177706569bcfc6240dcf8b41c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:52a15b0f35dad39862d376df10c5230155243a2c1a436e39eb55623ccbd68185" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:a30fd6fdef1430fd9e1ba7b3398b5ee4e2887783917a687d86ba69985fb08748" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cc9617b46837c6468197b5945e196ee9ca43057bb7d9d1ae688101e4e1dddf64" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:0ab74e19f6a2b027ea4f845a78827969af45ce790e6cb3e1ebab71bdf9f215ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dba5ee5d3981160c28d5490f0d1b7ed730c22470ff7f6cc26cfcfaacb9896a07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp313-cp313t-win_arm64.whl", hash = "sha256:0749fd8f4218ad2e851e11cc4dc05c7cbc0cbc4267bdfdb31782e65aace4ee9c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:9928fe1eb816d11ae170885a74d074f57af3a0d65777ca47e9aeb854a1fba386" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:d0005b053977e7b43388ddec89fa567f43d4f6d5c2c0affe57de5ebf290dc552" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:2635d352d67458b66fd0667c14cb1d4145e9560d503219034a18a87e971ce4f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:767c23ad1c58c9e827b649a9ab7809fd5fd9db266a9cf02b0e926ddc2c680d58" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:72d0eb9fba308b8311685c2268cf7d0a0639a6cd027d8128659f72bdd8a024b4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f68e4f3eeca8fb22cc3d731f9715a13b652795ef657a13df1ad0c7dc0e9731df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d84cd4061ae292d8ac367b2c3fa3aad11cb8625a95d135fe93f286f914f3f5a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:a60ea74330b91bd22a29638940d115df9dc00af5035a9a2a6ad9399ffb4ceca5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ce6a3a4e106cf35c2d9c4fa17c05ce0b180db622736845d4315519397a77beaf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:77937e5e2a38a7b48eef0585114fe7930346993a88060d0bf886086d2aa49ef5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:24c175051354f4a28c5d6a31c93906dc653e2bf234e8a4bbfb964892078898ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-win_amd64.whl", hash = "sha256:0763515d4df10edf6d06a3c19734e2566368980d21ebec439f33f9eb936c07b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314-win_arm64.whl", hash = "sha256:0e4e2bf29574a6a7b7f6cb5fa69293b9f96c928949ac4a53ba3f525dffb87f9c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d976bbb382b202f71c67f77b0ac11244021cfa3f7dfd9e562eefcea2df711548" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2489e4e5d7ef9a1c300a5e0196e43d9c739f066ef23270607d45aba368b91f2d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:e2ea9f7ab7fbf18fffb1b5434ce7c69a07582f7acc7717720f1d69f3e806f90c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b34e51affded8faee0dfdb705416153819d8ea9250bbbf7ea1b249bdeb5f1122" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d8aacd3d4b33b772542b2e01beb50187536967b514b00003bdda7589722d2a64" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:7cf974dd4e35fa315563ac99d6287a1024e4dc2077b8a7d7cd3d2fb65d283134" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:85bd218b5ecfbee8c8a82e121802dcb519a86044c9c3b2e4aef02fa05c6da370" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:0856e241c2d3df4efef7c04a1e46b1936b6120c9bcf36dd216e3acd84bc4fb21" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9af39d6551f97d31a4deebeac6f45b156f9755ddc59c07b402c148f5dbb6482a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:bb4ae2b57fc1d8cbd1cf7b1d9913803681ffa903e7488012be5b76dedf49297f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:aedff62918805fb62d43a4aa2ecd4482c380dc76cd31bd7c8878588a61bd0369" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-win_amd64.whl", hash = "sha256:1fa333e8b2ce4d9660f2cda9c0e1b6bafcfb2457a9d259faa82289e73ec24891" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-cp314-cp314t-win_arm64.whl", hash = "sha256:4a48a2ce79d65d363597ef7b567ce3d14d68783d2b2263d98db3d9477805ba32" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:720e05574713db64c356e86732c0f3c5252818d05f9df320f0ad8380641acea5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:17680d737d5335b552994a2008fab4c851bcd7de33094a82067ef3a576ff02fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:85b5352f94e490c028926ea567fc569c52ec79ce131dadb968d3853e809518c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-pp311-pypy311_pp73-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:464415881e4801295659462c49461a24fb107c140de781d55518c4b80cb6790f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/kiwisolver/kiwisolver-1.4.9-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:fb940820c63a9590d31d88b815e7a3aa5915cad3ce735ab45f0c730b39547de1" }, +] + +[[package]] +name = "libtpu" +version = "0.0.30" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp311-cp311-manylinux_2_31_x86_64.whl", hash = "sha256:b1fc44915dad56c0ceb733311a4d4396b88dc9a1c7c01acd7617da90e7ec22f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp312-cp312-manylinux_2_31_x86_64.whl", hash = "sha256:26442f0a51d243cf7259407bba8f5d849c9024297efe97044d64b5244283ad63" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp313-cp313-manylinux_2_31_x86_64.whl", hash = "sha256:5fabff9a041674bb889fb59ac0b5c54b9dbcf492a8c782e083ef86a8194dbb0f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp313-cp313t-manylinux_2_31_x86_64.whl", hash = "sha256:8be30562743a63c1c1353e7ba78f0dbfbb051e8d1e9d3bb2b5da9b720363bb0a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp314-cp314-manylinux_2_31_x86_64.whl", hash = "sha256:babab04ca663da2c4e4b3ab036c4d465f2f4674c480d08239c5d4965b7ce9e1c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/libtpu/libtpu-0.0.30-cp314-cp314t-manylinux_2_31_x86_64.whl", hash = "sha256:f9aa040895ec25fafebcd4e1a0e1a9524ff3bd778ca88543731e308f6e516dd1" }, +] + +[[package]] +name = "llvmlite" +version = "0.46.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0.tar.gz", hash = "sha256:227c9fd6d09dce2783c18b754b7cd9d9b3b3515210c46acc2d3c5badd9870ceb" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:82f3d39b16f19aa1a56d5fe625883a6ab600d5cc9ea8906cca70ce94cabba067" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a3df43900119803bbc52720e758c76f316a9a0f34612a886862dfe0a5591a17e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:de183fefc8022d21b0aa37fc3e90410bc3524aed8617f0ff76732fc6c3af5361" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp311-cp311-win_amd64.whl", hash = "sha256:e8b10bc585c58bdffec9e0c309bb7d51be1f2f15e169a4b4d42f2389e431eb93" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6b9588ad4c63b4f0175a3984b85494f0c927c6b001e3a246a3a7fb3920d9a137" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3535bd2bb6a2d7ae4012681ac228e5132cdb75fefb1bcb24e33f2f3e0c865ed4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cbfd366e60ff87ea6cc62f50bc4cd800ebb13ed4c149466f50cf2163a473d1e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp312-cp312-win_amd64.whl", hash = "sha256:398b39db462c39563a97b912d4f2866cd37cba60537975a09679b28fbbc0fb38" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:30b60892d034bc560e0ec6654737aaa74e5ca327bd8114d82136aa071d611172" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:6cc19b051753368a9c9f31dc041299059ee91aceec81bd57b0e385e5d5bf1a54" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bca185892908f9ede48c0acd547fe4dc1bafefb8a4967d47db6cf664f9332d12" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp313-cp313-win_amd64.whl", hash = "sha256:67438fd30e12349ebb054d86a5a1a57fd5e87d264d2451bcfafbbbaa25b82a35" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:d252edfb9f4ac1fcf20652258e3f102b26b03eef738dc8a6ffdab7d7d341d547" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:379fdd1c59badeff8982cb47e4694a6143bec3bb49aa10a466e095410522064d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e8cbfff7f6db0fa2c771ad24154e2a7e457c2444d7673e6de06b8b698c3b269" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/llvmlite/llvmlite-0.46.0-cp314-cp314-win_amd64.whl", hash = "sha256:7821eda3ec1f18050f981819756631d60b6d7ab1a6cf806d9efefbe3f4082d61" }, +] + +[[package]] +name = "markdown-it-py" +version = "4.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "mdurl" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markdown-it-py/markdown_it_py-4.0.0.tar.gz", hash = "sha256:cb0a2b4aa34f932c007117b194e945bd74e0ec24133ceb5bac59009cda1cb9f3" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markdown-it-py/markdown_it_py-4.0.0-py3-none-any.whl", hash = "sha256:87327c59b172c5011896038353a81343b6754500a08cd7a4973bb48c6d578147" }, +] + +[[package]] +name = "markupsafe" +version = "3.0.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3.tar.gz", hash = "sha256:722695808f4b6457b320fdc131280796bdceb04ab50fe1795cd540799ebe1698" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1cc7ea17a6824959616c525620e387f6dd30fec8cb44f649e31712db02123dad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bd4cd07944443f5a265608cc6aab442e4f74dff8088b0dfc8238647b8f6ae9a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b5420a1d9450023228968e7e6a9ce57f65d148ab56d2313fcd589eee96a7a50" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0bf2a864d67e76e5c9a34dc26ec616a66b9888e25e7b9460e1c76d3293bd9dbf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:bc51efed119bc9cfdf792cdeaa4d67e8f6fcccab66ed4bfdd6bde3e59bfcbb2f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:068f375c472b3e7acbe2d5318dea141359e6900156b5b2ba06a30b169086b91a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:7be7b61bb172e1ed687f1754f8e7484f1c8019780f6f6b0786e76bb01c2ae115" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f9e130248f4462aaa8e2552d547f36ddadbeaa573879158d721bbd33dfe4743a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-win32.whl", hash = "sha256:0db14f5dafddbb6d9208827849fad01f1a2609380add406671a26386cdf15a19" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:de8a88e63464af587c950061a5e6a67d3632e36df62b986892331d4620a35c01" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp311-cp311-win_arm64.whl", hash = "sha256:3b562dd9e9ea93f13d53989d23a7e775fdfd1066c33494ff43f5418bc8c58a5c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d53197da72cc091b024dd97249dfc7794d6a56530370992a5e1a08983ad9230e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1872df69a4de6aead3491198eaf13810b565bdbeec3ae2dc8780f14458ec73ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a7e8ae81ae39e62a41ec302f972ba6ae23a5c5396c8e60113e9066ef893da0d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d6dd0be5b5b189d31db7cda48b91d7e0a9795f31430b7f271219ab30f1d3ac9d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:94c6f0bb423f739146aec64595853541634bde58b2135f27f61c1ffd1cd4d16a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:be8813b57049a7dc738189df53d69395eba14fb99345e0a5994914a3864c8a4b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:83891d0e9fb81a825d9a6d61e3f07550ca70a076484292a70fde82c4b807286f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:77f0643abe7495da77fb436f50f8dab76dbc6e5fd25d39589a0f1fe6548bfa2b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-win32.whl", hash = "sha256:d88b440e37a16e651bda4c7c2b930eb586fd15ca7406cb39e211fcff3bf3017d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:26a5784ded40c9e318cfc2bdb30fe164bdb8665ded9cd64d500a34fb42067b1c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:35add3b638a5d900e807944a078b51922212fb3dedb01633a8defc4b01a3c85f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:e1cf1972137e83c5d4c136c43ced9ac51d0e124706ee1c8aa8532c1287fa8795" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:116bb52f642a37c115f517494ea5feb03889e04df47eeff5b130b1808ce7c219" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:133a43e73a802c5562be9bbcd03d090aa5a1fe899db609c29e8c8d815c5f6de6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfcd093f13f0f0b7fdd0f198b90053bf7b2f02a3927a30e63f3ccc9df56b676" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:509fa21c6deb7a7a273d629cf5ec029bc209d1a51178615ddf718f5918992ab9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a4afe79fb3de0b7097d81da19090f4df4f8d3a2b3adaa8764138aac2e44f3af1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:795e7751525cae078558e679d646ae45574b47ed6e7771863fcc079a6171a0fc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8485f406a96febb5140bfeca44a73e3ce5116b2501ac54fe953e488fb1d03b12" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-win32.whl", hash = "sha256:bdd37121970bfd8be76c5fb069c7751683bdf373db1ed6c010162b2a130248ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:9a1abfdc021a164803f4d485104931fb8f8c1efd55bc6b748d2f5774e78b62c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:7e68f88e5b8799aa49c85cd116c932a1ac15caaa3f5db09087854d218359e485" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:218551f6df4868a8d527e3062d0fb968682fe92054e89978594c28e642c43a73" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3524b778fe5cfb3452a09d31e7b5adefeea8c5be1d43c4f810ba09f2ceb29d37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4e885a3d1efa2eadc93c894a21770e4bc67899e3543680313b09f139e149ab19" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8709b08f4a89aa7586de0aadc8da56180242ee0ada3999749b183aa23df95025" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:b8512a91625c9b3da6f127803b166b629725e68af71f8184ae7e7d54686a56d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9b79b7a16f7fedff2495d684f2b59b0457c3b493778c9eed31111be64d58279f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:12c63dfb4a98206f045aa9563db46507995f7ef6d83b2f68eda65c307c6829eb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8f71bc33915be5186016f675cd83a1e08523649b0e33efdb898db577ef5bb009" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-win32.whl", hash = "sha256:69c0b73548bc525c8cb9a251cddf1931d1db4d2258e9599c28c07ef3580ef354" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-win_amd64.whl", hash = "sha256:1b4b79e8ebf6b55351f0d91fe80f893b4743f104bff22e90697db1590e47a218" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp313-cp313t-win_arm64.whl", hash = "sha256:ad2cf8aa28b8c020ab2fc8287b0f823d0a7d8630784c31e9ee5edea20f406287" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:eaa9599de571d72e2daf60164784109f19978b327a3910d3e9de8c97b5b70cfe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c47a551199eb8eb2121d4f0f15ae0f923d31350ab9280078d1e5f12b249e0026" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f34c41761022dd093b4b6896d4810782ffbabe30f2d443ff5f083e0cbbb8c737" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:457a69a9577064c05a97c41f4e65148652db078a3a509039e64d3467b9e7ef97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:e8afc3f2ccfa24215f8cb28dcf43f0113ac3c37c2f0f0806d8c70e4228c5cf4d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:ec15a59cf5af7be74194f7ab02d0f59a62bdcf1a537677ce67a2537c9b87fcda" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:0eb9ff8191e8498cca014656ae6b8d61f39da5f95b488805da4bb029cccbfbaf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2713baf880df847f2bece4230d4d094280f4e67b1e813eec43b4c0e144a34ffe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-win32.whl", hash = "sha256:729586769a26dbceff69f7a7dbbf59ab6572b99d94576a5592625d5b411576b9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:bdc919ead48f234740ad807933cdf545180bfbe9342c2bb451556db2ed958581" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:5a7d5dc5140555cf21a6fefbdbf8723f06fcd2f63ef108f2854de715e4422cb4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:1353ef0c1b138e1907ae78e2f6c63ff67501122006b0f9abad68fda5f4ffc6ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1085e7fbddd3be5f89cc898938f42c0b3c711fdcb37d75221de2666af647c175" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1b52b4fb9df4eb9ae465f8d0c228a00624de2334f216f178a995ccdcf82c4634" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fed51ac40f757d41b7c48425901843666a6677e3e8eb0abcff09e4ba6e664f50" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:f190daf01f13c72eac4efd5c430a8de82489d9cff23c364c3ea822545032993e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e56b7d45a839a697b5eb268c82a71bd8c7f6c94d6fd50c3d577fa39a9f1409f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:f3e98bb3798ead92273dc0e5fd0f31ade220f59a266ffd8a4f6065e0a3ce0523" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5678211cb9333a6468fb8d8be0305520aa073f50d17f089b5b4b477ea6e67fdc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-win32.whl", hash = "sha256:915c04ba3851909ce68ccc2b8e2cd691618c4dc4c4232fb7982bca3f41fd8c3d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4faffd047e07c38848ce017e8725090413cd80cbc23d86e55c587bf979e579c9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/markupsafe/markupsafe-3.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:32001d6a8fc98c8cb5c947787c5d08b0a50663d139f1305bac5885d98d9b40fa" }, +] + +[[package]] +name = "marshmallow" +version = "3.26.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "packaging" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/marshmallow/marshmallow-3.26.2.tar.gz", hash = "sha256:bbe2adb5a03e6e3571b573f42527c6fe926e17467833660bebd11593ab8dfd57" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/marshmallow/marshmallow-3.26.2-py3-none-any.whl", hash = "sha256:013fa8a3c4c276c24d26d84ce934dc964e2aa794345a0f8c7e5a7191482c8a73" }, +] + +[[package]] +name = "matplotlib" +version = "3.10.8" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8.tar.gz", hash = "sha256:2299372c19d56bcd35cf05a2738308758d32b9eaed2371898d8f5bd33f084aa3" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:6be43b667360fef5c754dda5d25a32e6307a03c204f3c0fc5468b78fa87b4160" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a2b336e2d91a3d7006864e0990c83b216fcdca64b5a6484912902cef87313d78" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:efb30e3baaea72ce5928e32bab719ab4770099079d66726a62b11b1ef7273be4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d56a1efd5bfd61486c8bc968fa18734464556f0fb8e51690f4ac25d85cbbbbc2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:238b7ce5717600615c895050239ec955d91f321c209dd110db988500558e70d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-win_amd64.whl", hash = "sha256:18821ace09c763ec93aef5eeff087ee493a24051936d7b9ebcad9662f66501f9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp311-cp311-win_arm64.whl", hash = "sha256:bab485bcf8b1c7d2060b4fcb6fc368a9e6f4cd754c9c2fea281f4be21df394a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:64fcc24778ca0404ce0cb7b6b77ae1f4c7231cdd60e6778f999ee05cbd581b9a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b9a5ca4ac220a0cdd1ba6bcba3608547117d30468fefce49bb26f55c1a3d5c58" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:3ab4aabc72de4ff77b3ec33a6d78a68227bf1123465887f9905ba79184a1cc04" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:24d50994d8c5816ddc35411e50a86ab05f575e2530c02752e02538122613371f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:99eefd13c0dc3b3c1b4d561c1169e65fe47aab7b8158754d7c084088e2329466" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-win_amd64.whl", hash = "sha256:dd80ecb295460a5d9d260df63c43f4afbdd832d725a531f008dad1664f458adf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp312-cp312-win_arm64.whl", hash = "sha256:3c624e43ed56313651bc18a47f838b60d7b8032ed348911c54906b130b20071b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3f2e409836d7f5ac2f1c013110a4d50b9f7edc26328c108915f9075d7d7a91b6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56271f3dac49a88d7fca5060f004d9d22b865f743a12a23b1e937a0be4818ee1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a0a7f52498f72f13d4a25ea70f35f4cb60642b466cbb0a9be951b5bc3f45a486" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:646d95230efb9ca614a7a594d4fcacde0ac61d25e37dd51710b36477594963ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f89c151aab2e2e23cb3fe0acad1e8b82841fd265379c4cecd0f3fcb34c15e0f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-win_amd64.whl", hash = "sha256:e8ea3e2d4066083e264e75c829078f9e149fa119d27e19acd503de65e0b13149" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313-win_arm64.whl", hash = "sha256:c108a1d6fa78a50646029cb6d49808ff0fc1330fda87fa6f6250c6b5369b6645" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:ad3d9833a64cf48cc4300f2b406c3d0f4f4724a91c0bd5640678a6ba7c102077" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:eb3823f11823deade26ce3b9f40dcb4a213da7a670013929f31d5f5ed1055b22" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d9050fee89a89ed57b4fb2c1bfac9a3d0c57a0d55aed95949eedbc42070fea39" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b44d07310e404ba95f8c25aa5536f154c0a8ec473303535949e52eb71d0a1565" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:0a33deb84c15ede243aead39f77e990469fff93ad1521163305095b77b72ce4a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-win_amd64.whl", hash = "sha256:3a48a78d2786784cc2413e57397981fb45c79e968d99656706018d6e62e57958" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp313-cp313t-win_arm64.whl", hash = "sha256:15d30132718972c2c074cd14638c7f4592bd98719e2308bccea40e0538bc0cb5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b53285e65d4fa4c86399979e956235deb900be5baa7fc1218ea67fbfaeaadd6f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:32f8dce744be5569bebe789e46727946041199030db8aeb2954d26013a0eb26b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4cf267add95b1c88300d96ca837833d4112756045364f5c734a2276038dae27d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2cf5bd12cecf46908f286d7838b2abc6c91cda506c0445b8223a7c19a00df008" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:41703cc95688f2516b480f7f339d8851a6035f18e100ee6a32bc0b8536a12a9c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-win_amd64.whl", hash = "sha256:83d282364ea9f3e52363da262ce32a09dfe241e4080dcedda3c0db059d3c1f11" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314-win_arm64.whl", hash = "sha256:2c1998e92cd5999e295a731bcb2911c75f597d937341f3030cc24ef2733d78a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b5a2b97dbdc7d4f353ebf343744f1d1f1cca8aa8bfddb4262fcf4306c3761d50" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3f5c3e4da343bba819f0234186b9004faba952cc420fbc522dc4e103c1985908" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5f62550b9a30afde8c1c3ae450e5eb547d579dd69b25c2fc7a1c67f934c1717a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:495672de149445ec1b772ff2c9ede9b769e3cb4f0d0aa7fa730d7f59e2d4e1c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:595ba4d8fe983b88f0eec8c26a241e16d6376fe1979086232f481f8f3f67494c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-win_amd64.whl", hash = "sha256:25d380fe8b1dc32cf8f0b1b448470a77afb195438bafdf1d858bfb876f3edf7b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-cp314-cp314t-win_arm64.whl", hash = "sha256:113bb52413ea508ce954a02c10ffd0d565f9c3bc7f2eddc27dfe1731e71c7b5f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:6da7c2ce169267d0d066adcf63758f0604aa6c3eebf67458930f9d9b79ad1db1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:9153c3292705be9f9c64498a8872118540c3f4123d1a1c840172edf262c8be4a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib/matplotlib-3.10.8-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1ae029229a57cd1e8fe542485f27e7ca7b23aa9e8944ddb4985d0bc444f1eca2" }, +] + +[[package]] +name = "matplotlib-inline" +version = "0.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "traitlets" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib-inline/matplotlib_inline-0.2.1.tar.gz", hash = "sha256:e1ee949c340d771fc39e241ea75683deb94762c8fa5f2927ec57c83c4dffa9fe" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/matplotlib-inline/matplotlib_inline-0.2.1-py3-none-any.whl", hash = "sha256:d56ce5156ba6085e00a9d54fead6ed29a9c47e215cd1bba2e976ef39f5710a76" }, +] + +[[package]] +name = "mdit-py-plugins" +version = "0.5.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "markdown-it-py" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mdit-py-plugins/mdit_py_plugins-0.5.0.tar.gz", hash = "sha256:f4918cb50119f50446560513a8e311d574ff6aaed72606ddae6d35716fe809c6" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mdit-py-plugins/mdit_py_plugins-0.5.0-py3-none-any.whl", hash = "sha256:07a08422fc1936a5d26d146759e9155ea466e842f5ab2f7d2266dd084c8dab1f" }, +] + +[[package]] +name = "mdurl" +version = "0.1.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mdurl/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mdurl/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8" }, +] + +[[package]] +name = "ml-collections" +version = "1.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "pyyaml" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-collections/ml_collections-1.1.0.tar.gz", hash = "sha256:0ac1ac6511b9f1566863e0bb0afad0c64e906ea278ad3f4d2144a55322671f6f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-collections/ml_collections-1.1.0-py3-none-any.whl", hash = "sha256:23b6fa4772aac1ae745a96044b925a5746145a70734f087eaca6626e92c05cbc" }, +] + +[[package]] +name = "ml-dtypes" +version = "0.5.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6c7ecb74c4bd71db68a6bea1edf8da8c34f3d9fe218f038814fd1d310ac76c90" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bc11d7e8c44a65115d05e2ab9989d1e045125d7be8e05a071a48bc76eb6d6040" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:19b9a53598f21e453ea2fbda8aa783c20faff8e1eeb0d7ab899309a0053f1483" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp311-cp311-win_amd64.whl", hash = "sha256:7c23c54a00ae43edf48d44066a7ec31e05fdc2eee0be2b8b50dd1903a1db94bb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp311-cp311-win_arm64.whl", hash = "sha256:557a31a390b7e9439056644cb80ed0735a6e3e3bb09d67fd5687e4b04238d1de" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a174837a64f5b16cab6f368171a1a03a27936b31699d167684073ff1c4237dac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a7f7c643e8b1320fd958bf098aa7ecf70623a42ec5154e3be3be673f4c34d900" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ad459e99793fa6e13bd5b7e6792c8f9190b4e5a1b45c63aba14a4d0a7f1d5ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:c1a953995cccb9e25a4ae19e34316671e4e2edaebe4cf538229b1fc7109087b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:9bad06436568442575beb2d03389aa7456c690a5b05892c471215bfd8cf39460" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8c760d85a2f82e2bed75867079188c9d18dae2ee77c25a54d60e9cc79be1bc48" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ce756d3a10d0c4067172804c9cc276ba9cc0ff47af9078ad439b075d1abdc29b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:533ce891ba774eabf607172254f2e7260ba5f57bdd64030c9a4fcfbd99815d0d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:f21c9219ef48ca5ee78402d5cc831bd58ea27ce89beda894428bc67a52da5328" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:35f29491a3e478407f7047b8a4834e4640a77d2737e0b294d049746507af5175" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:304ad47faa395415b9ccbcc06a0350800bc50eda70f0e45326796e27c62f18b6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6a0df4223b514d799b8a1629c65ddc351b3efa833ccf7f8ea0cf654a61d1e35d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:531eff30e4d368cb6255bc2328d070e35836aa4f282a0fb5f3a0cd7260257298" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313t-win_amd64.whl", hash = "sha256:cb73dccfc991691c444acc8c0012bee8f2470da826a92e3a20bb333b1a7894e6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp313-cp313t-win_arm64.whl", hash = "sha256:3bbbe120b915090d9dd1375e4684dd17a20a2491ef25d640a908281da85e73f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:2b857d3af6ac0d39db1de7c706e69c7f9791627209c3d6dedbfca8c7e5faec22" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:805cef3a38f4eafae3a5bf9ebdcdb741d0bcfd9e1bd90eb54abd24f928cd2465" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14a4fd3228af936461db66faccef6e4f41c1d82fcc30e9f8d58a08916b1d811f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:8c6a2dcebd6f3903e05d51960a8058d6e131fe69f952a5397e5dbabc841b6d56" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:5a0f68ca8fd8d16583dfa7793973feb86f2fbb56ce3966daf9c9f748f52a2049" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:bfc534409c5d4b0bf945af29e5d0ab075eae9eecbb549ff8a29280db822f34f9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2314892cdc3fcf05e373d76d72aaa15fda9fb98625effa73c1d646f331fcecb7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d2ffd05a2575b1519dc928c0b93c06339eb67173ff53acb00724502cda231cf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:4381fe2f2452a2d7589689693d3162e876b3ddb0a832cde7a414f8e1adf7eab1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ml-dtypes/ml_dtypes-0.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:11942cbf2cf92157db91e5022633c0d9474d4dfd813a909383bd23ce828a4b7d" }, +] + +[[package]] +name = "mpmath" +version = "1.3.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mpmath/mpmath-1.3.0.tar.gz", hash = "sha256:7a28eb2a9774d00c7bc92411c19a89209d5da7c4c9a9e227be8330a23a25b91f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mpmath/mpmath-1.3.0-py3-none-any.whl", hash = "sha256:a0b2b9fe80bbcd81a6647ff13108738cfb482d481d826cc0e02f5b35e5c88d2c" }, +] + +[[package]] +name = "msgpack" +version = "1.1.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2.tar.gz", hash = "sha256:3b60763c1373dd60f398488069bcdc703cd08a711477b5d480eecc9f9626f47e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2e86a607e558d22985d856948c12a3fa7b42efad264dca8a3ebbcfa2735d786c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:283ae72fc89da59aa004ba147e8fc2f766647b1251500182fac0350d8af299c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:61c8aa3bd513d87c72ed0b37b53dd5c5a0f58f2ff9f26e1555d3bd7948fb7296" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:454e29e186285d2ebe65be34629fa0e8605202c60fbc7c4c650ccd41870896ef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7bc8813f88417599564fafa59fd6f95be417179f76b40325b500b3c98409757c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bafca952dc13907bdfdedfc6a5f579bf4f292bdd506fadb38389afa3ac5b208e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-win32.whl", hash = "sha256:602b6740e95ffc55bfb078172d279de3773d7b7db1f703b2f1323566b878b90e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-win_amd64.whl", hash = "sha256:d198d275222dc54244bf3327eb8cbe00307d220241d9cec4d306d49a44e85f68" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp311-cp311-win_arm64.whl", hash = "sha256:86f8136dfa5c116365a8a651a7d7484b65b13339731dd6faebb9a0242151c406" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:70a0dff9d1f8da25179ffcf880e10cf1aad55fdb63cd59c9a49a1b82290062aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:446abdd8b94b55c800ac34b102dffd2f6aa0ce643c55dfc017ad89347db3dbdb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c63eea553c69ab05b6747901b97d620bb2a690633c77f23feb0c6a947a8a7b8f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:372839311ccf6bdaf39b00b61288e0557916c3729529b301c52c2d88842add42" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2929af52106ca73fcb28576218476ffbb531a036c2adbcf54a3664de124303e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:be52a8fc79e45b0364210eef5234a7cf8d330836d0a64dfbb878efa903d84620" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-win32.whl", hash = "sha256:1fff3d825d7859ac888b0fbda39a42d59193543920eda9d9bea44d958a878029" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-win_amd64.whl", hash = "sha256:1de460f0403172cff81169a30b9a92b260cb809c4cb7e2fc79ae8d0510c78b6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp312-cp312-win_arm64.whl", hash = "sha256:be5980f3ee0e6bd44f3a9e9dea01054f175b50c3e6cdb692bc9424c0bbb8bf69" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4efd7b5979ccb539c221a4c4e16aac1a533efc97f3b759bb5a5ac9f6d10383bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:42eefe2c3e2af97ed470eec850facbe1b5ad1d6eacdbadc42ec98e7dcf68b4b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fdf7d83102bf09e7ce3357de96c59b627395352a4024f6e2458501f158bf999" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fac4be746328f90caa3cd4bc67e6fe36ca2bf61d5c6eb6d895b6527e3f05071e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fffee09044073e69f2bad787071aeec727183e7580443dfeb8556cbf1978d162" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5928604de9b032bc17f5099496417f113c45bc6bc21b5c6920caf34b3c428794" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-win32.whl", hash = "sha256:a7787d353595c7c7e145e2331abf8b7ff1e6673a6b974ded96e6d4ec09f00c8c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-win_amd64.whl", hash = "sha256:a465f0dceb8e13a487e54c07d04ae3ba131c7c5b95e2612596eafde1dccf64a9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp313-cp313-win_arm64.whl", hash = "sha256:e69b39f8c0aa5ec24b57737ebee40be647035158f14ed4b40e6f150077e21a84" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:e23ce8d5f7aa6ea6d2a2b326b4ba46c985dbb204523759984430db7114f8aa00" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:6c15b7d74c939ebe620dd8e559384be806204d73b4f9356320632d783d1f7939" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99e2cb7b9031568a2a5c73aa077180f93dd2e95b4f8d3b8e14a73ae94a9e667e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:180759d89a057eab503cf62eeec0aa61c4ea1200dee709f3a8e9397dbb3b6931" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:04fb995247a6e83830b62f0b07bf36540c213f6eac8e851166d8d86d83cbd014" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:8e22ab046fa7ede9e36eeb4cfad44d46450f37bb05d5ec482b02868f451c95e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-win32.whl", hash = "sha256:80a0ff7d4abf5fecb995fcf235d4064b9a9a8a40a3ab80999e6ac1e30b702717" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-win_amd64.whl", hash = "sha256:9ade919fac6a3e7260b7f64cea89df6bec59104987cbea34d34a2fa15d74310b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314-win_arm64.whl", hash = "sha256:59415c6076b1e30e563eb732e23b994a61c159cec44deaf584e5cc1dd662f2af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:897c478140877e5307760b0ea66e0932738879e7aa68144d9b78ea4c8302a84a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a668204fa43e6d02f89dbe79a30b0d67238d9ec4c5bd8a940fc3a004a47b721b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5559d03930d3aa0f3aacb4c42c776af1a2ace2611871c84a75afe436695e6245" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:70c5a7a9fea7f036b716191c29047374c10721c389c21e9ffafad04df8c52c90" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f2cb069d8b981abc72b41aea1c580ce92d57c673ec61af4c500153a626cb9e20" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d62ce1f483f355f61adb5433ebfd8868c5f078d1a52d042b0a998682b4fa8c27" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-win32.whl", hash = "sha256:1d1418482b1ee984625d88aa9585db570180c286d942da463533b238b98b812b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-win_amd64.whl", hash = "sha256:5a46bf7e831d09470ad92dff02b8b1ac92175ca36b087f904a0519857c6be3ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/msgpack/msgpack-1.1.2-cp314-cp314t-win_arm64.whl", hash = "sha256:d99ef64f349d5ec3293688e91486c5fdb925ed03807f64d98d205d2713c60b46" }, +] + +[[package]] +name = "multidict" +version = "6.7.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1.tar.gz", hash = "sha256:ec6652a1bee61c53a3e5776b6049172c53b6aaba34f18c9ad04f82712bac623d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7ff981b266af91d7b4b3793ca3382e53229088d193a85dfad6f5f4c27fc73e5d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:844c5bca0b5444adb44a623fb0a1310c2f4cd41f402126bb269cd44c9b3f3e1e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f2a0a924d4c2e9afcd7ec64f9de35fcd96915149b2216e1cb2c10a56df483855" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:8be1802715a8e892c784c0197c2ace276ea52702a0ede98b6310c8f255a5afb3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2e2d2ed645ea29f31c4c7ea1552fcfd7cb7ba656e1eafd4134a6620c9f5fdd9e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:95922cee9a778659e91db6497596435777bd25ed116701a4c034f8e46544955a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6b83cabdc375ffaaa15edd97eb7c0c672ad788e2687004990074d7d6c9b140c8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:38fb49540705369bab8484db0689d86c0a33a0a9f2c1b197f506b71b4b6c19b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:439cbebd499f92e9aa6793016a8acaa161dfa749ae86d20960189f5398a19144" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6d3bc717b6fe763b8be3f2bee2701d3c8eb1b2a8ae9f60910f1b2860c82b6c49" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:619e5a1ac57986dbfec9f0b301d865dddf763696435e2962f6d9cf2fdff2bb71" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:0b38ebffd9be37c1170d33bc0f36f4f262e0a09bc1aac1c34c7aa51a7293f0b3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:10ae39c9cfe6adedcdb764f5e8411d4a92b055e35573a2eaa88d3323289ef93c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:25167cc263257660290fba06b9318d2026e3c910be240a146e1f66dd114af2b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:128441d052254f42989ef98b7b6a6ecb1e6f708aa962c7984235316db59f50fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-win32.whl", hash = "sha256:d62b7f64ffde3b99d06b707a280db04fb3855b55f5a06df387236051d0668f4a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-win_amd64.whl", hash = "sha256:bdbf9f3b332abd0cdb306e7c2113818ab1e922dc84b8f8fd06ec89ed2a19ab8b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp311-cp311-win_arm64.whl", hash = "sha256:b8c990b037d2fff2f4e33d3f21b9b531c5745b33a49a7d6dbe7a177266af44f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:a90f75c956e32891a4eda3639ce6dd86e87105271f43d43442a3aedf3cddf172" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:3fccb473e87eaa1382689053e4a4618e7ba7b9b9b8d6adf2027ee474597128cd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b0fa96985700739c4c7853a43c0b3e169360d6855780021bfc6d0f1ce7c123e7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cb2a55f408c3043e42b40cc8eecd575afa27b7e0b956dfb190de0f8499a57a53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eb0ce7b2a32d09892b3dd6cc44877a0d02a33241fafca5f25c8b6b62374f8b75" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c3a32d23520ee37bf327d1e1a656fec76a2edd5c038bf43eddfa0572ec49c60b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:9c90fed18bffc0189ba814749fdcc102b536e83a9f738a9003e569acd540a733" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:da62917e6076f512daccfbbde27f46fed1c98fee202f0559adec8ee0de67f71a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bfde23ef6ed9db7eaee6c37dcec08524cb43903c60b285b172b6c094711b3961" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:3758692429e4e32f1ba0df23219cd0b4fc0a52f476726fff9337d1a57676a582" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:398c1478926eca669f2fd6a5856b6de9c0acf23a2cb59a14c0ba5844fa38077e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c102791b1c4f3ab36ce4101154549105a53dc828f016356b3e3bcae2e3a039d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a088b62bd733e2ad12c50dad01b7d0166c30287c166e137433d3b410add807a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:3d51ff4785d58d3f6c91bdbffcb5e1f7ddfda557727043aa20d20ec4f65e324a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc5907494fccf3e7d3f94f95c91d6336b092b5fc83811720fae5e2765890dfba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-win32.whl", hash = "sha256:28ca5ce2fd9716631133d0e9a9b9a745ad7f60bac2bccafb56aa380fc0b6c511" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcee94dfbd638784645b066074b338bc9cc155d4b4bffa4adce1615c5a426c19" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp312-cp312-win_arm64.whl", hash = "sha256:ba0a9fb644d0c1a2194cf7ffb043bd852cea63a57f66fbd33959f7dae18517bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2b41f5fed0ed563624f1c17630cb9941cf2309d4df00e494b551b5f3e3d67a23" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:84e61e3af5463c19b67ced91f6c634effb89ef8bfc5ca0267f954451ed4bb6a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:935434b9853c7c112eee7ac891bc4cb86455aa631269ae35442cb316790c1445" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:432feb25a1cb67fe82a9680b4d65fb542e4635cb3166cd9c01560651ad60f177" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e82d14e3c948952a1a85503817e038cba5905a3352de76b9a465075d072fba23" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:4cfb48c6ea66c83bcaaf7e4dfa7ec1b6bbcf751b7db85a328902796dfde4c060" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:1d540e51b7e8e170174555edecddbd5538105443754539193e3e1061864d444d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:273d23f4b40f3dce4d6c8a821c741a86dec62cded82e1175ba3d99be128147ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d624335fd4fa1c08a53f8b4be7676ebde19cd092b3895c421045ca87895b429" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:12fad252f8b267cc75b66e8fc51b3079604e8d43a75428ffe193cd9e2195dfd6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:03ede2a6ffbe8ef936b92cb4529f27f42be7f56afcdab5ab739cd5f27fb1cbf9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:90efbcf47dbe33dcf643a1e400d67d59abeac5db07dc3f27d6bdeae497a2198c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:5c4b9bfc148f5a91be9244d6264c53035c8a0dcd2f51f1c3c6e30e30ebaa1c84" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:401c5a650f3add2472d1d288c26deebc540f99e2fb83e9525007a74cd2116f1d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:97891f3b1b3ffbded884e2916cacf3c6fc87b66bb0dde46f7357404750559f33" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-win32.whl", hash = "sha256:e1c5988359516095535c4301af38d8a8838534158f649c05dd1050222321bcb3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:960c83bf01a95b12b08fd54324a4eb1d5b52c88932b5cba5d6e712bb3ed12eb5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313-win_arm64.whl", hash = "sha256:563fe25c678aaba333d5399408f5ec3c383ca5b663e7f774dd179a520b8144df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:c76c4bec1538375dad9d452d246ca5368ad6e1c9039dadcf007ae59c70619ea1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:57b46b24b5d5ebcc978da4ec23a819a9402b4228b8a90d9c656422b4bdd8a963" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e954b24433c768ce78ab7929e84ccf3422e46deb45a4dc9f93438f8217fa2d34" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:3bd231490fa7217cc832528e1cd8752a96f0125ddd2b5749390f7c3ec8721b65" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:253282d70d67885a15c8a7716f3a73edf2d635793ceda8173b9ecc21f2fb8292" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0b4c48648d7649c9335cf1927a8b87fa692de3dcb15faa676c6a6f1f1aabda43" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:98bc624954ec4d2c7cb074b8eefc2b5d0ce7d482e410df446414355d158fe4ca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1b99af4d9eec0b49927b4402bcbb58dea89d3e0db8806a4086117019939ad3dd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6aac4f16b472d5b7dc6f66a0d49dd57b0e0902090be16594dc9ebfd3d17c47e7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:21f830fe223215dffd51f538e78c172ed7c7f60c9b96a2bf05c4848ad49921c3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f5dd81c45b05518b9aa4da4aa74e1c93d715efa234fd3e8a179df611cc85e5f4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:eb304767bca2bb92fb9c5bd33cedc95baee5bb5f6c88e63706533a1c06ad08c8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:c9035dde0f916702850ef66460bc4239d89d08df4d02023a5926e7446724212c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:af959b9beeb66c822380f222f0e0a1889331597e81f1ded7f374f3ecb0fd6c52" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:41f2952231456154ee479651491e94118229844dd7226541788be783be2b5108" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-win32.whl", hash = "sha256:df9f19c28adcb40b6aae30bbaa1478c389efd50c28d541d76760199fc1037c32" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-win_amd64.whl", hash = "sha256:d54ecf9f301853f2c5e802da559604b3e95bb7a3b01a9c295c6ee591b9882de8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp313-cp313t-win_arm64.whl", hash = "sha256:5a37ca18e360377cfda1d62f5f382ff41f2b8c4ccb329ed974cc2e1643440118" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8f333ec9c5eb1b7105e3b84b53141e66ca05a19a605368c55450b6ba208cb9ee" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a407f13c188f804c759fc6a9f88286a565c242a76b27626594c133b82883b5c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0e161ddf326db5577c3a4cc2d8648f81456e8a20d40415541587a71620d7a7d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:1e3a8bb24342a8201d178c3b4984c26ba81a577c80d4d525727427460a50c22d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:97231140a50f5d447d3164f994b86a0bed7cd016e2682f8650d6a9158e14fd31" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6b10359683bd8806a200fd2909e7c8ca3a7b24ec1d8132e483d58e791d881048" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:283ddac99f7ac25a4acadbf004cb5ae34480bbeb063520f70ce397b281859362" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:538cec1e18c067d0e6103aa9a74f9e832904c957adc260e61cd9d8cf0c3b3d37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7eee46ccb30ff48a1e35bb818cc90846c6be2b68240e42a78599166722cea709" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:fa263a02f4f2dd2d11a7b1bb4362aa7cb1049f84a9235d31adf63f30143469a0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:2e1425e2f99ec5bd36c15a01b690a1a2456209c5deed58f95469ffb46039ccbb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:497394b3239fc6f0e13a78a3e1b61296e72bf1c5f94b4c4eb80b265c37a131cd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:233b398c29d3f1b9676b4b6f75c518a06fcb2ea0b925119fb2c1bc35c05e1601" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:93b1818e4a6e0930454f0f2af7dfce69307ca03cdcfb3739bf4d91241967b6c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f33dc2a3abe9249ea5d8360f969ec7f4142e7ac45ee7014d8f8d5acddf178b7b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-win32.whl", hash = "sha256:3ab8b9d8b75aef9df299595d5388b14530839f6422333357af1339443cff777d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:5e01429a929600e7dab7b166062d9bb54a5eed752384c7384c968c2afab8f50f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314-win_arm64.whl", hash = "sha256:4885cb0e817aef5d00a2e8451d4665c1808378dc27c2705f1bf4ef8505c0d2e5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:0458c978acd8e6ea53c81eefaddbbee9c6c5e591f41b3f5e8e194780fe026581" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:c0abd12629b0af3cf590982c0b413b1e7395cd4ec026f30986818ab95bfaa94a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:14525a5f61d7d0c94b368a42cff4c9a4e7ba2d52e2672a7b23d84dc86fb02b0c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:17307b22c217b4cf05033dabefe68255a534d637c6c9b0cc8382718f87be4262" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7a7e590ff876a3eaf1c02a4dfe0724b6e69a9e9de6d8f556816f29c496046e59" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:5fa6a95dfee63893d80a34758cd0e0c118a30b8dcb46372bf75106c591b77889" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a0543217a6a017692aa6ae5cc39adb75e587af0f3a82288b1492eb73dd6cc2a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f99fe611c312b3c1c0ace793f92464d8cd263cc3b26b5721950d977b006b6c4d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9004d8386d133b7e6135679424c91b0b854d2d164af6ea3f289f8f2761064609" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:e628ef0e6859ffd8273c69412a2465c4be4a9517d07261b33334b5ec6f3c7489" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:841189848ba629c3552035a6a7f5bf3b02eb304e9fea7492ca220a8eda6b0e5c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:ce1bbd7d780bb5a0da032e095c951f7014d6b0a205f8318308140f1a6aba159e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b26684587228afed0d50cf804cc71062cc9c1cdf55051c4c6345d372947b268c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9f9af11306994335398293f9958071019e3ab95e9a707dc1383a35613f6abcb9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:b4938326284c4f1224178a560987b6cf8b4d38458b113d9b8c1db1a836e640a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-win32.whl", hash = "sha256:98655c737850c064a65e006a3df7c997cd3b220be4ec8fe26215760b9697d4d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-win_amd64.whl", hash = "sha256:497bde6223c212ba11d462853cfa4f0ae6ef97465033e7dc9940cdb3ab5b48e5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-cp314-cp314t-win_arm64.whl", hash = "sha256:2bbd113e0d4af5db41d5ebfe9ccaff89de2120578164f86a5d17d5a576d1e5b2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multidict/multidict-6.7.1-py3-none-any.whl", hash = "sha256:55d97cc6dae627efa6a6e548885712d4864b81110ac76fa4e534c03819fa4a56" }, +] + +[[package]] +name = "multiprocess" +version = "0.70.18" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "dill" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b8940ae30139e04b076da6c5b83e9398585ebdf0f2ad3250673fef5b2ff06d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:0929ba95831adb938edbd5fb801ac45e705ecad9d100b3e653946b7716cb6bd3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:4d77f8e4bfe6c6e2e661925bbf9aed4d5ade9a1c6502d5dfc10129b9d1141797" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py310-none-any.whl", hash = "sha256:60c194974c31784019c1f459d984e8f33ee48f10fcf42c309ba97b30d9bd53ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py311-none-any.whl", hash = "sha256:5aa6eef98e691281b3ad923be2832bf1c55dd2c859acd73e5ec53a66aae06a1d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py312-none-any.whl", hash = "sha256:9b78f8e5024b573730bfb654783a13800c2c0f2dfc0c25e70b40d184d64adaa2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py313-none-any.whl", hash = "sha256:871743755f43ef57d7910a38433cfe41319e72be1bbd90b79c7a5ac523eb9334" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py38-none-any.whl", hash = "sha256:dbf705e52a154fe5e90fb17b38f02556169557c2dd8bb084f2e06c2784d8279b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/multiprocess/multiprocess-0.70.18-py39-none-any.whl", hash = "sha256:e78ca805a72b1b810c690b6b4cc32579eba34f403094bbbae962b7b5bf9dfcb8" }, +] + +[[package]] +name = "mypy-extensions" +version = "1.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mypy-extensions/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/mypy-extensions/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505" }, +] + +[[package]] +name = "myst-nb" +version = "1.3.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "importlib-metadata" }, + { name = "ipykernel" }, + { name = "ipython" }, + { name = "jupyter-cache" }, + { name = "myst-parser" }, + { name = "nbclient" }, + { name = "nbformat" }, + { name = "pyyaml" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/myst-nb/myst_nb-1.3.0.tar.gz", hash = "sha256:df3cd4680f51a5af673fd46b38b562be3559aef1475e906ed0f2e66e4587ce4b" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/myst-nb/myst_nb-1.3.0-py3-none-any.whl", hash = "sha256:1f36af3c19964960ec4e51ac30949b6ed6df220356ffa8d60dd410885e132d7d" }, +] + +[[package]] +name = "myst-parser" +version = "5.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "docutils" }, + { name = "jinja2" }, + { name = "markdown-it-py" }, + { name = "mdit-py-plugins" }, + { name = "pyyaml" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/myst-parser/myst_parser-5.0.0.tar.gz", hash = "sha256:f6f231452c56e8baa662cc352c548158f6a16fcbd6e3800fc594978002b94f3a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/myst-parser/myst_parser-5.0.0-py3-none-any.whl", hash = "sha256:ab31e516024918296e169139072b81592336f2fef55b8986aa31c9f04b5f7211" }, +] + +[[package]] +name = "nbclient" +version = "0.10.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "jupyter-client" }, + { name = "jupyter-core" }, + { name = "nbformat" }, + { name = "traitlets" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nbclient/nbclient-0.10.4.tar.gz", hash = "sha256:1e54091b16e6da39e297b0ece3e10f6f29f4ac4e8ee515d29f8a7099bd6553c9" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nbclient/nbclient-0.10.4-py3-none-any.whl", hash = "sha256:9162df5a7373d70d606527300a95a975a47c137776cd942e52d9c7e29ff83440" }, +] + +[[package]] +name = "nbformat" +version = "5.10.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "fastjsonschema" }, + { name = "jsonschema" }, + { name = "jupyter-core" }, + { name = "traitlets" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nbformat/nbformat-5.10.4.tar.gz", hash = "sha256:322168b14f937a5d11362988ecac2a4952d3d8e3a2cbeb2319584631226d5b3a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nbformat/nbformat-5.10.4-py3-none-any.whl", hash = "sha256:3b48d6c8fbca4b299bf3982ea7db1af21580e4fec269ad087b9e81588891200b" }, +] + +[[package]] +name = "nest-asyncio" +version = "1.6.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nest-asyncio/nest_asyncio-1.6.0.tar.gz", hash = "sha256:6f172d5449aca15afd6c646851f4e31e02c598d553a667e38cafa997cfec55fe" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/nest-asyncio/nest_asyncio-1.6.0-py3-none-any.whl", hash = "sha256:87af6efd6b5e897c81050477ef65c62e2b2f35d51703cae01aff2905b1852e1c" }, +] + +[[package]] +name = "numba" +version = "0.63.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "llvmlite" }, + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1.tar.gz", hash = "sha256:b320aa675d0e3b17b40364935ea52a7b1c670c9037c39cf92c49502a75902f4b" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b33db00f18ccc790ee9911ce03fcdfe9d5124637d1ecc266f5ae0df06e02fec3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7d31ea186a78a7c0f6b1b2a3fe68057fdb291b045c52d86232b5383b6cf4fc25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ed3bb2fbdb651d6aac394388130a7001aab6f4541837123a4b4ab8b02716530c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp311-cp311-win_amd64.whl", hash = "sha256:1ecbff7688f044b1601be70113e2fb1835367ee0b28ffa8f3adf3a05418c5c87" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2819cd52afa5d8d04e057bdfd54367575105f8829350d8fb5e4066fb7591cc71" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:5cfd45dbd3d409e713b1ccfdc2ee72ca82006860254429f4ef01867fdba5845f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69a599df6976c03b7ecf15d05302696f79f7e6d10d620367407517943355bcb0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp312-cp312-win_amd64.whl", hash = "sha256:bbad8c63e4fc7eb3cdb2c2da52178e180419f7969f9a685f283b313a70b92af3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:0bd4fd820ef7442dcc07da184c3f54bb41d2bdb7b35bacf3448e73d081f730dc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:53de693abe4be3bd4dee38e1c55f01c55ff644a6a3696a3670589e6e4c39cde2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:81227821a72a763c3d4ac290abbb4371d855b59fdf85d5af22a47c0e86bf8c7e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp313-cp313-win_amd64.whl", hash = "sha256:eb227b07c2ac37b09432a9bda5142047a2d1055646e089d4a240a2643e508102" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:f180883e5508940cc83de8a8bea37fc6dd20fbe4e5558d4659b8b9bef5ff4731" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:f0938764afa82a47c0e895637a6c55547a42c9e1d35cac42285b1fa60a8b02bb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f90a929fa5094e062d4e0368ede1f4497d5e40f800e80aa5222c4734236a2894" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numba/numba-0.63.1-cp314-cp314-win_amd64.whl", hash = "sha256:8d6d5ce85f572ed4e1a135dbb8c0114538f9dd0e3657eeb0bb64ab204cbe2a8f" }, +] + +[[package]] +name = "numpy" +version = "2.3.5" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5.tar.gz", hash = "sha256:784db1dcdab56bf0517743e746dfb0f885fc68d948aba86eeec2cba234bdf1c0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de5672f4a7b200c15a4127042170a694d4df43c992948f5e1af57f0174beed10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:acfd89508504a19ed06ef963ad544ec6664518c863436306153e13e94605c218" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:ffe22d2b05504f786c867c8395de703937f934272eb67586817b46188b4ded6d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:872a5cf366aec6bb1147336480fef14c9164b154aeb6542327de4970282cd2f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3095bdb8dd297e5920b010e96134ed91d852d81d490e787beca7e35ae1d89cf7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8cba086a43d54ca804ce711b2a940b16e452807acebe7852ff327f1ecd49b0d4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6cf9b429b21df6b99f4dee7a1218b8b7ffbbe7df8764dc0bd60ce8a0708fed1e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:396084a36abdb603546b119d96528c2f6263921c50df3c8fd7cb28873a237748" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-win32.whl", hash = "sha256:b0c7088a73aef3d687c4deef8452a3ac7c1be4e29ed8bf3b366c8111128ac60c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-win_amd64.whl", hash = "sha256:a414504bef8945eae5f2d7cb7be2d4af77c5d1cb5e20b296c2c25b61dff2900c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp311-cp311-win_arm64.whl", hash = "sha256:0cd00b7b36e35398fa2d16af7b907b65304ef8bb4817a550e06e5012929830fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:74ae7b798248fe62021dbf3c914245ad45d1a6b0cb4a29ecb4b31d0bfbc4cc3e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ee3888d9ff7c14604052b2ca5535a30216aa0a58e948cdd3eeb8d3415f638769" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:612a95a17655e213502f60cfb9bf9408efdc9eb1d5f50535cc6eb365d11b42b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:3101e5177d114a593d79dd79658650fe28b5a0d8abeb8ce6f437c0e6df5be1a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b973c57ff8e184109db042c842423ff4f60446239bd585a5131cc47f06f789d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0d8163f43acde9a73c2a33605353a4f1bc4798745a8b1d73183b28e5b435ae28" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:51c1e14eb1e154ebd80e860722f9e6ed6ec89714ad2db2d3aa33c31d7c12179b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b46b4ec24f7293f23adcd2d146960559aaf8020213de8ad1909dba6c013bf89c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-win32.whl", hash = "sha256:3997b5b3c9a771e157f9aae01dd579ee35ad7109be18db0e85dbdbe1de06e952" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-win_amd64.whl", hash = "sha256:86945f2ee6d10cdfd67bcb4069c1662dd711f7e2a4343db5cecec06b87cf31aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp312-cp312-win_arm64.whl", hash = "sha256:f28620fe26bee16243be2b7b874da327312240a7cdc38b769a697578d2100013" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d0f23b44f57077c1ede8c5f26b30f706498b4862d3ff0a7298b8411dd2f043ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:aa5bc7c5d59d831d9773d1170acac7893ce3a5e130540605770ade83280e7188" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:ccc933afd4d20aad3c00bcef049cb40049f7f196e0397f1109dba6fed63267b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afaffc4393205524af9dfa400fa250143a6c3bc646c08c9f5e25a9f4b4d6a903" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9c75442b2209b8470d6d5d8b1c25714270686f14c749028d2199c54e29f20b4d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:11e06aa0af8c0f05104d56450d6093ee639e15f24ecf62d417329d06e522e017" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ed89927b86296067b4f81f108a2271d8926467a8868e554eaf370fc27fa3ccaf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:51c55fe3451421f3a6ef9a9c1439e82101c57a2c9eab9feb196a62b1a10b58ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-win32.whl", hash = "sha256:1978155dd49972084bd6ef388d66ab70f0c323ddee6f693d539376498720fb7e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-win_amd64.whl", hash = "sha256:00dc4e846108a382c5869e77c6ed514394bdeb3403461d25a829711041217d5b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313-win_arm64.whl", hash = "sha256:0472f11f6ec23a74a906a00b48a4dcf3849209696dff7c189714511268d103ae" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:414802f3b97f3c1eef41e530aaba3b3c1620649871d8cb38c6eaff034c2e16bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5ee6609ac3604fa7780e30a03e5e241a7956f8e2fcfe547d51e3afa5247ac47f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:86d835afea1eaa143012a2d7a3f45a3adce2d7adc8b4961f0b362214d800846a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:30bc11310e8153ca664b14c5f1b73e94bd0503681fcf136a163de856f3a50139" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1062fde1dcf469571705945b0f221b73928f34a20c904ffb45db101907c3454e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ce581db493ea1a96c0556360ede6607496e8bf9b3a8efa66e06477267bc831e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:cc8920d2ec5fa99875b670bb86ddeb21e295cb07aa331810d9e486e0b969d946" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:9ee2197ef8c4f0dfe405d835f3b6a14f5fee7782b5de51ba06fb65fc9b36e9f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-win32.whl", hash = "sha256:70b37199913c1bd300ff6e2693316c6f869c7ee16378faf10e4f5e3275b299c3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-win_amd64.whl", hash = "sha256:b501b5fa195cc9e24fe102f21ec0a44dffc231d2af79950b451e0d99cea02234" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp313-cp313t-win_arm64.whl", hash = "sha256:a80afd79f45f3c4a7d341f13acbe058d1ca8ac017c165d3fa0d3de6bc1a079d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:bf06bc2af43fa8d32d30fae16ad965663e966b1a3202ed407b84c989c3221e82" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:052e8c42e0c49d2575621c158934920524f6c5da05a1d3b9bab5d8e259e045f0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:1ed1ec893cff7040a02c8aa1c8611b94d395590d553f6b53629a4461dc7f7b63" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2dcd0808a421a482a080f89859a18beb0b3d1e905b81e617a188bd80422d62e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:727fd05b57df37dc0bcf1a27767a3d9a78cbbc92822445f32cc3436ba797337b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fffe29a1ef00883599d1dc2c51aa2e5d80afe49523c261a74933df395c15c520" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8f7f0e05112916223d3f438f293abf0727e1181b5983f413dfa2fefc4098245c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:2e2eb32ddb9ccb817d620ac1d8dae7c3f641c1e5f55f531a33e8ab97960a75b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-win32.whl", hash = "sha256:66f85ce62c70b843bab1fb14a05d5737741e74e28c7b8b5a064de10142fad248" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-win_amd64.whl", hash = "sha256:e6a0bc88393d65807d751a614207b7129a310ca4fe76a74e5c7da5fa5671417e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314-win_arm64.whl", hash = "sha256:aeffcab3d4b43712bb7a60b65f6044d444e75e563ff6180af8f98dd4b905dfd2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:17531366a2e3a9e30762c000f2c43a9aaa05728712e25c11ce1dbe700c53ad41" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d21644de1b609825ede2f48be98dfde4656aefc713654eeee280e37cadc4e0ad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:c804e3a5aba5460c73955c955bdbd5c08c354954e9270a2c1565f62e866bdc39" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:cc0a57f895b96ec78969c34f682c602bf8da1a0270b09bc65673df2e7638ec20" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:900218e456384ea676e24ea6a0417f030a3b07306d29d7ad843957b40a9d8d52" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:09a1bea522b25109bf8e6f3027bd810f7c1085c64a0c7ce050c1676ad0ba010b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:04822c00b5fd0323c8166d66c701dc31b7fbd252c100acd708c48f763968d6a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:d6889ec4ec662a1a37eb4b4fb26b6100841804dac55bd9df579e326cdc146227" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-win32.whl", hash = "sha256:93eebbcf1aafdf7e2ddd44c2923e2672e1010bddc014138b229e49725b4d6be5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-win_amd64.whl", hash = "sha256:c8a9958e88b65c3b27e22ca2a076311636850b612d6bbfb76e8d156aacde2aaf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-cp314-cp314t-win_arm64.whl", hash = "sha256:6203fdf9f3dc5bdaed7319ad8698e685c7a3be10819f41d32a0723e611733b42" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:f0963b55cdd70fad460fa4c1341f12f976bb26cb66021a5580329bd498988310" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:f4255143f5160d0de972d28c8f9665d882b5f61309d8362fdd3e103cf7bf010c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_arm64.whl", hash = "sha256:a4b9159734b326535f4dd01d947f919c6eefd2d9827466a696c44ced82dfbc18" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-macosx_14_0_x86_64.whl", hash = "sha256:2feae0d2c91d46e59fcd62784a3a83b3fb677fead592ce51b5a6fbb4f95965ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ffac52f28a7849ad7576293c0cb7b9f08304e8f7d738a8cb8a90ec4c55a998eb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63c0e9e7eea69588479ebf4a8a270d5ac22763cc5854e9a7eae952a3908103f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/numpy/numpy-2.3.5-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:f16417ec91f12f814b10bafe79ef77e70113a2f5f7018640e7425ff979253425" }, +] + +[[package]] +name = "omegaconf" +version = "2.3.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "antlr4-python3-runtime" }, + { name = "pyyaml" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/omegaconf/omegaconf-2.3.0.tar.gz", hash = "sha256:d5d4b6d29955cc50ad50c46dc269bcd92c6e00f5f90d23ab5fee7bfca4ba4cc7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/omegaconf/omegaconf-2.3.0-py3-none-any.whl", hash = "sha256:7b4df175cdb08ba400f45cae3bdcae7ba8365db4d165fc65fd04b050ab63b46b" }, +] + +[[package]] +name = "opt-einsum" +version = "3.4.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/opt-einsum/opt_einsum-3.4.0.tar.gz", hash = "sha256:96ca72f1b886d148241348783498194c577fa30a8faac108586b14f1ba4473ac" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/opt-einsum/opt_einsum-3.4.0-py3-none-any.whl", hash = "sha256:69bb92469f86a1565195ece4ac0323943e83477171b91d24c35afe028a90d7cd" }, +] + +[[package]] +name = "optax" +version = "0.2.6" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "chex" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/optax/optax-0.2.6.tar.gz", hash = "sha256:ba8d1e12678eba2657484d6feeca4fb281b8066bdfd5efbfc0f41b87663109c0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/optax/optax-0.2.6-py3-none-any.whl", hash = "sha256:f875251a5ab20f179d4be57478354e8e21963373b10f9c3b762b94dcb8c36d91" }, +] + +[[package]] +name = "orbax-checkpoint" +version = "0.11.32" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "aiofiles" }, + { name = "etils", extra = ["epath", "epy"] }, + { name = "humanize" }, + { name = "jax" }, + { name = "msgpack" }, + { name = "nest-asyncio" }, + { name = "numpy" }, + { name = "protobuf" }, + { name = "psutil" }, + { name = "pyyaml" }, + { name = "simplejson" }, + { name = "tensorstore" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/orbax-checkpoint/orbax_checkpoint-0.11.32.tar.gz", hash = "sha256:523dcf61e93c7187c6b80fd50f3177114c0b957ea62cbb5c869c0b3e3d1a7dfc" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/orbax-checkpoint/orbax_checkpoint-0.11.32-py3-none-any.whl", hash = "sha256:f0bfe9f9b1ce2c32c8f5dfab63393e51de525d41352abc17c7e21f9cc731d7a9" }, +] + +[[package]] +name = "orbax-export" +version = "0.0.8" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "dataclasses-json" }, + { name = "etils" }, + { name = "jax" }, + { name = "jaxlib" }, + { name = "jaxtyping" }, + { name = "numpy" }, + { name = "orbax-checkpoint" }, + { name = "protobuf" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/orbax-export/orbax_export-0.0.8.tar.gz", hash = "sha256:544eef564e2a6f17cd11b1167febe348b7b7cf56d9575de994a33d5613dd568a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/orbax-export/orbax_export-0.0.8-py3-none-any.whl", hash = "sha256:f8037e1666ad28411cdb08d0668a2737b1281a32902c623ceda12109a089bc36" }, +] + +[[package]] +name = "packaging" +version = "26.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/packaging/packaging-26.0.tar.gz", hash = "sha256:00243ae351a257117b6a241061796684b084ed1c516a08c48a3f7e147a9d80b4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/packaging/packaging-26.0-py3-none-any.whl", hash = "sha256:b36f1fef9334a5588b4166f8bcd26a14e521f2b55e6b9de3aaa80d3ff7a37529" }, +] + +[[package]] +name = "pandas" +version = "3.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, + { name = "python-dateutil" }, + { name = "tzdata", marker = "sys_platform == 'emscripten' or sys_platform == 'win32'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1.tar.gz", hash = "sha256:4186a699674af418f655dbd420ed87f50d56b4cd6603784279d9eef6627823c8" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:de09668c1bf3b925c07e5762291602f0d789eca1b3a781f99c1c78f6cac0e7ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:24ba315ba3d6e5806063ac6eb717504e499ce30bd8c236d8693a5fd3f084c796" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:406ce835c55bac912f2a0dcfaf27c06d73c6b04a5dde45f1fd3169ce31337389" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:830994d7e1f31dd7e790045235605ab61cff6c94defc774547e8b7fdfbff3dc7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:a64ce8b0f2de1d2efd2ae40b0abe7f8ae6b29fbfb3812098ed5a6f8e235ad9bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:9832c2c69da24b602c32e0c7b1b508a03949c18ba08d4d9f1c1033426685b447" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:84f0904a69e7365f79a0c77d3cdfccbfb05bf87847e3a51a41e1426b0edb9c79" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp311-cp311-win_arm64.whl", hash = "sha256:4a68773d5a778afb31d12e34f7dd4612ab90de8c6fb1d8ffe5d4a03b955082a1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:476f84f8c20c9f5bc47252b66b4bb25e1a9fc2fa98cead96744d8116cb85771d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0ab749dfba921edf641d4036c4c21c0b3ea70fea478165cb98a998fb2a261955" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b8e36891080b87823aff3640c78649b91b8ff6eea3c0d70aeabd72ea43ab069b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:532527a701281b9dd371e2f582ed9094f4c12dd9ffb82c0c54ee28d8ac9520c4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:356e5c055ed9b0da1580d465657bc7d00635af4fd47f30afb23025352ba764d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9d810036895f9ad6345b8f2a338dd6998a74e8483847403582cab67745bff821" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:536232a5fe26dd989bd633e7a0c450705fdc86a207fec7254a55e9a22950fe43" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp312-cp312-win_arm64.whl", hash = "sha256:0f463ebfd8de7f326d38037c7363c6dacb857c5881ab8961fb387804d6daf2f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5272627187b5d9c20e55d27caf5f2cd23e286aba25cadf73c8590e432e2b7262" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:661e0f665932af88c7877f31da0dc743fe9c8f2524bdffe23d24fdcb67ef9d56" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:75e6e292ff898679e47a2199172593d9f6107fd2dd3617c22c2946e97d5df46e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ff8cf1d2896e34343197685f432450ec99a85ba8d90cce2030c5eee2ef98791" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eca8b4510f6763f3d37359c2105df03a7a221a508f30e396a51d0713d462e68a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:06aff2ad6f0b94a17822cf8b83bbb563b090ed82ff4fe7712db2ce57cd50d9b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:9fea306c783e28884c29057a1d9baa11a349bbf99538ec1da44c8476563d1b25" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313-win_arm64.whl", hash = "sha256:a8d37a43c52917427e897cb2e429f67a449327394396a81034a4449b99afda59" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d54855f04f8246ed7b6fc96b05d4871591143c46c0b6f4af874764ed0d2d6f06" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e1b677accee34a09e0dc2ce5624e4a58a1870ffe56fc021e9caf7f23cd7668f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a9cabbdcd03f1b6cd254d6dda8ae09b0252524be1592594c00b7895916cb1324" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5ae2ab1f166668b41e770650101e7090824fd34d17915dd9cd479f5c5e0065e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:6bf0603c2e30e2cafac32807b06435f28741135cb8697eae8b28c7d492fc7d76" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6c426422973973cae1f4a23e51d4ae85974f44871b24844e4f7de752dd877098" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b03f91ae8c10a85c1613102c7bef5229b5379f343030a3ccefeca8a33414cf35" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:99d0f92ed92d3083d140bf6b97774f9f13863924cf3f52a70711f4e7588f9d0a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:3b66857e983208654294bb6477b8a63dee26b37bdd0eb34d010556e91261784f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:56cf59638bf24dc9bdf2154c81e248b3289f9a09a6d04e63608c159022352749" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1a9f55e0f46951874b863d1f3906dcb57df2d9be5c5847ba4dfb55b2c815249" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1849f0bba9c8a2fb0f691d492b834cc8dadf617e29015c66e989448d58d011ee" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c3d288439e11b5325b02ae6e9cc83e6805a62c40c5a6220bea9beb899c073b1c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:93325b0fe372d192965f4cca88d97667f49557398bbf94abdda3bf1b591dbe66" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314-win_arm64.whl", hash = "sha256:97ca08674e3287c7148f4858b01136f8bdfe7202ad25ad04fec602dd1d29d132" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:58eeb1b2e0fb322befcf2bbc9ba0af41e616abadb3d3414a6bc7167f6cbfce32" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:cd9af1276b5ca9e298bd79a26bda32fa9cc87ed095b2a9a60978d2ca058eaf87" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:94f87a04984d6b63788327cd9f79dda62b7f9043909d2440ceccf709249ca988" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85fe4c4df62e1e20f9db6ebfb88c844b092c22cd5324bdcf94bfa2fc1b391221" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:331ca75a2f8672c365ae25c0b29e46f5ac0c6551fdace8eec4cd65e4fac271ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:15860b1fdb1973fffade772fdb931ccf9b2f400a3f5665aef94a00445d7d8dd5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:44f1364411d5670efa692b146c748f4ed013df91ee91e9bec5677fb1fd58b937" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pandas/pandas-3.0.1-cp314-cp314t-win_arm64.whl", hash = "sha256:108dd1790337a494aa80e38def654ca3f0968cf4f362c85f44c15e471667102d" }, +] + +[[package]] +name = "parso" +version = "0.8.6" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/parso/parso-0.8.6.tar.gz", hash = "sha256:2b9a0332696df97d454fa67b81618fd69c35a7b90327cbe6ba5c92d2c68a7bfd" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/parso/parso-0.8.6-py2.py3-none-any.whl", hash = "sha256:2c549f800b70a5c4952197248825584cb00f033b29c692671d3bf08bf380baff" }, +] + +[[package]] +name = "pexpect" +version = "4.9.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "ptyprocess" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pexpect/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pexpect/pexpect-4.9.0-py2.py3-none-any.whl", hash = "sha256:7236d1e080e4936be2dc3e326cec0af72acf9212a7e1d060210e70a47e253523" }, +] + +[[package]] +name = "pillow" +version = "12.1.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pillow/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e" }, +] + +[[package]] +name = "platformdirs" +version = "4.9.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/platformdirs/platformdirs-4.9.2.tar.gz", hash = "sha256:9a33809944b9db043ad67ca0db94b14bf452cc6aeaac46a88ea55b26e2e9d291" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/platformdirs/platformdirs-4.9.2-py3-none-any.whl", hash = "sha256:9170634f126f8efdae22fb58ae8a0eaa86f38365bc57897a6c4f781d1f5875bd" }, +] + +[[package]] +name = "promise" +version = "2.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/promise/promise-2.3.tar.gz", hash = "sha256:dfd18337c523ba4b6a58801c164c1904a9d4d1b1747c7d5dbf45b693a49d93d0" } + +[[package]] +name = "prompt-toolkit" +version = "3.0.52" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "wcwidth" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/prompt-toolkit/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/prompt-toolkit/prompt_toolkit-3.0.52-py3-none-any.whl", hash = "sha256:9aac639a3bbd33284347de5ad8d68ecc044b91a762dc39b7c21095fcd6a19955" }, +] + +[[package]] +name = "propcache" +version = "0.4.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:60a8fda9644b7dfd5dece8c61d8a85e271cb958075bfc4e01083c148b61a7caf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c30b53e7e6bda1d547cabb47c825f3843a0a1a42b0496087bb58d8fedf9f41b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6918ecbd897443087a3b7cd978d56546a812517dcaaca51b49526720571fa93e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d902a36df4e5989763425a8ab9e98cd8ad5c52c823b34ee7ef307fd50582566" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a9695397f85973bb40427dedddf70d8dc4a44b22f1650dd4af9eedf443d45165" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2bb07ffd7eaad486576430c89f9b215f9e4be68c4866a96e97db9e97fead85dc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fd6f30fdcf9ae2a70abd34da54f18da086160e4d7d9251f81f3da0ff84fc5a48" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:fc38cba02d1acba4e2869eef1a57a43dfbd3d49a59bf90dda7444ec2be6a5570" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:67fad6162281e80e882fb3ec355398cf72864a54069d060321f6cd0ade95fe85" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:f10207adf04d08bec185bae14d9606a1444715bc99180f9331c9c02093e1959e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:e9b0d8d0845bbc4cfcdcbcdbf5086886bc8157aa963c31c777ceff7846c77757" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:981333cb2f4c1896a12f4ab92a9cc8f09ea664e9b7dbdc4eff74627af3a11c0f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-win32.whl", hash = "sha256:f1d2f90aeec838a52f1c1a32fe9a619fefd5e411721a9117fbf82aea638fe8a1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:364426a62660f3f699949ac8c621aad6977be7126c5807ce48c0aeb8e7333ea6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp311-cp311-win_arm64.whl", hash = "sha256:e53f3a38d3510c11953f3e6a33f205c6d1b001129f972805ca9b42fc308bc239" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/propcache/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237" }, +] + +[[package]] +name = "protobuf" +version = "6.33.5" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5.tar.gz", hash = "sha256:6ddcac2a081f8b7b9642c09406bc6a4290128fce5f471cddd165960bb9119e5c" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp310-abi3-win32.whl", hash = "sha256:d71b040839446bac0f4d162e758bea99c8251161dae9d0983a3b88dee345153b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp310-abi3-win_amd64.whl", hash = "sha256:3093804752167bcab3998bec9f1048baae6e29505adaf1afd14a37bddede533c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:a5cb85982d95d906df1e2210e58f8e4f1e3cdc088e52c921a041f9c9a0386de5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:9b71e0281f36f179d00cbcb119cb19dec4d14a81393e5ea220f64b286173e190" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp39-abi3-manylinux2014_s390x.whl", hash = "sha256:8afa18e1d6d20af15b417e728e9f60f3aa108ee76f23c3b2c07a2c3b546d3afd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:cbf16ba3350fb7b889fca858fb215967792dc125b35c7976ca4818bee3521cf0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/protobuf/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02" }, +] + +[[package]] +name = "psutil" +version = "7.2.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2.tar.gz", hash = "sha256:0746f5f8d406af344fd547f1c8daa5f5c33dbc293bb8d6a16d80b4bb88f59372" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2edccc433cbfa046b980b0df0171cd25bcaeb3a68fe9022db0979e7aa74a826b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:e78c8603dcd9a04c7364f1a3e670cea95d51ee865e4efb3556a3a63adef958ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1a571f2330c966c62aeda00dd24620425d4b0cc86881c89861fbc04549e5dc63" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:917e891983ca3c1887b4ef36447b1e0873e70c933afc831c6b6da078ba474312" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:ab486563df44c17f5173621c7b198955bd6b613fb87c71c161f827d3fb149a9b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp313-cp313t-win_arm64.whl", hash = "sha256:ae0aefdd8796a7737eccea863f80f81e468a1e4cf14d926bd9b6f5f2d5f90ca9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:eed63d3b4d62449571547b60578c5b2c4bcccc5387148db46e0c2313dad0ee00" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:7b6d09433a10592ce39b13d7be5a54fbac1d1228ed29abc880fb23df7cb694c9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1fa4ecf83bcdf6e6c8f4449aff98eefb5d0604bf88cb883d7da3d8d2d909546a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e452c464a02e7dc7822a05d25db4cde564444a67e58539a00f929c51eddda0cf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-win_amd64.whl", hash = "sha256:c7663d4e37f13e884d13994247449e9f8f574bc4655d509c3b95e9ec9e2b9dc1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp314-cp314t-win_arm64.whl", hash = "sha256:11fe5a4f613759764e79c65cf11ebdf26e33d6dd34336f8a337aa2996d71c841" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:ed0cace939114f62738d808fdcecd4c869222507e266e574799e9c0faa17d486" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-macosx_11_0_arm64.whl", hash = "sha256:1a7b04c10f32cc88ab39cbf606e117fd74721c831c98a27dc04578deb0c16979" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-manylinux2010_x86_64.manylinux_2_12_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:076a2d2f923fd4821644f5ba89f059523da90dc9014e85f8e45a5774ca5bc6f9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b0726cecd84f9474419d67252add4ac0cd9811b04d61123054b9fb6f57df6e9e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fd04ef36b4a6d599bbdb225dd1d3f51e00105f6d48a28f006da7f9822f2606d8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp36-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b58fabe35e80b264a4e3bb23e6b96f9e45a3df7fb7eed419ac0e5947c61e47cc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp37-abi3-win_amd64.whl", hash = "sha256:eb7e81434c8d223ec4a219b5fc1c47d0417b12be7ea866e24fb5ad6e84b3d988" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/psutil/psutil-7.2.2-cp37-abi3-win_arm64.whl", hash = "sha256:8c233660f575a5a89e6d4cb65d9f938126312bca76d8fe087b947b3a1aaac9ee" }, +] + +[[package]] +name = "ptyprocess" +version = "0.7.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ptyprocess/ptyprocess-0.7.0.tar.gz", hash = "sha256:5c5d0a3b48ceee0b48485e0c26037c0acd7d29765ca3fbb5cb3831d347423220" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/ptyprocess/ptyprocess-0.7.0-py2.py3-none-any.whl", hash = "sha256:4b41f3967fce3af57cc7e94b888626c18bf37a083e3651ca8feeb66d492fef35" }, +] + +[[package]] +name = "pure-eval" +version = "0.2.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pure-eval/pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pure-eval/pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0" }, +] + +[[package]] +name = "pyarrow" +version = "23.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1.tar.gz", hash = "sha256:b8c5873e33440b2bc2f4a79d2b47017a89c5a24116c055625e6f2ee50523f019" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:6f0147ee9e0386f519c952cc670eb4a8b05caa594eeffe01af0e25f699e4e9bb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-macosx_12_0_x86_64.whl", hash = "sha256:0ae6e17c828455b6265d590100c295193f93cc5675eb0af59e49dbd00d2de350" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:fed7020203e9ef273360b9e45be52a2a47d3103caf156a30ace5247ffb51bdbd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:26d50dee49d741ac0e82185033488d28d35be4d763ae6f321f97d1140eb7a0e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3c30143b17161310f151f4a2bcfe41b5ff744238c1039338779424e38579d701" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:db2190fa79c80a23fdd29fef4b8992893f024ae7c17d2f5f4db7171fa30c2c78" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:f00f993a8179e0e1c9713bcc0baf6d6c01326a406a9c23495ec1ba9c9ebf2919" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:f4b0dbfa124c0bb161f8b5ebb40f1a680b70279aa0c9901d44a2b5a20806039f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-macosx_12_0_x86_64.whl", hash = "sha256:7707d2b6673f7de054e2e83d59f9e805939038eebe1763fe811ee8fa5c0cd1a7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:86ff03fb9f1a320266e0de855dee4b17da6794c595d207f89bba40d16b5c78b9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:813d99f31275919c383aab17f0f455a04f5a429c261cc411b1e9a8f5e4aaaa05" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bf5842f960cddd2ef757d486041d57c96483efc295a8c4a0e20e704cbbf39c67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:564baf97c858ecc03ec01a41062e8f4698abc3e6e2acd79c01c2e97880a19730" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:07deae7783782ac7250989a7b2ecde9b3c343a643f82e8a4df03d93b633006f0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:6b8fda694640b00e8af3c824f99f789e836720aa8c9379fb435d4c4953a756b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-macosx_12_0_x86_64.whl", hash = "sha256:8ff51b1addc469b9444b7c6f3548e19dc931b172ab234e995a60aea9f6e6025f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:71c5be5cbf1e1cb6169d2a0980850bccb558ddc9b747b6206435313c47c37677" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:9b6f4f17b43bc39d56fec96e53fe89d94bac3eb134137964371b45352d40d0c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9fc13fc6c403d1337acab46a2c4346ca6c9dec5780c3c697cf8abfd5e19b6b37" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5c16ed4f53247fa3ffb12a14d236de4213a4415d127fe9cebed33d51671113e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:cecfb12ef629cf6be0b1887f9f86463b0dd3dc3195ae6224e74006be4736035a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:29f7f7419a0e30264ea261fdc0e5fe63ce5a6095003db2945d7cd78df391a7e1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-macosx_12_0_x86_64.whl", hash = "sha256:33d648dc25b51fd8055c19e4261e813dfc4d2427f068bcecc8b53d01b81b0500" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_aarch64.whl", hash = "sha256:cd395abf8f91c673dd3589cadc8cc1ee4e8674fa61b2e923c8dd215d9c7d1f41" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:00be9576d970c31defb5c32eb72ef585bf600ef6d0a82d5eccaae96639cf9d07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c2139549494445609f35a5cda4eb94e2c9e4d704ce60a095b342f82460c73a83" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:7044b442f184d84e2351e5084600f0d7343d6117aabcbc1ac78eb1ae11eb4125" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a35581e856a2fafa12f3f54fce4331862b1cfb0bef5758347a858a4aa9d6bae8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:5df1161da23636a70838099d4aaa65142777185cc0cdba4037a18cee7d8db9ca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-macosx_12_0_x86_64.whl", hash = "sha256:fa8e51cb04b9f8c9c5ace6bab63af9a1f88d35c0d6cbf53e8c17c098552285e1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_aarch64.whl", hash = "sha256:0b95a3994f015be13c63148fef8832e8a23938128c185ee951c98908a696e0eb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-manylinux_2_28_x86_64.whl", hash = "sha256:4982d71350b1a6e5cfe1af742c53dfb759b11ce14141870d05d9e540d13bc5d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c250248f1fe266db627921c89b47b7c06fee0489ad95b04d50353537d74d6886" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f4763b83c11c16e5f4c15601ba6dfa849e20723b46aa2617cb4bffe8768479f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314-win_amd64.whl", hash = "sha256:3a4c85ef66c134161987c17b147d6bffdca4566f9a4c1d81a0a01cdf08414ea5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:17cd28e906c18af486a499422740298c52d7c6795344ea5002a7720b4eadf16d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-macosx_12_0_x86_64.whl", hash = "sha256:76e823d0e86b4fb5e1cf4a58d293036e678b5a4b03539be933d3b31f9406859f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_aarch64.whl", hash = "sha256:a62e1899e3078bf65943078b3ad2a6ddcacf2373bc06379aac61b1e548a75814" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-manylinux_2_28_x86_64.whl", hash = "sha256:df088e8f640c9fae3b1f495b3c64755c4e719091caf250f3a74d095ddf3c836d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:46718a220d64677c93bc243af1d44b55998255427588e400677d7192671845c7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:a09f3876e87f48bc2f13583ab551f0379e5dfb83210391e68ace404181a20690" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyarrow/pyarrow-23.0.1-cp314-cp314t-win_amd64.whl", hash = "sha256:527e8d899f14bd15b740cd5a54ad56b7f98044955373a17179d5956ddb93d9ce" }, +] + +[[package]] +name = "pycparser" +version = "3.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pycparser/pycparser-3.0.tar.gz", hash = "sha256:600f49d217304a5902ac3c37e1281c9fe94e4d0489de643a9504c5cdfdfc6b29" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pycparser/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992" }, +] + +[[package]] +name = "pydata-sphinx-theme" +version = "0.15.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "accessible-pygments" }, + { name = "babel" }, + { name = "beautifulsoup4" }, + { name = "docutils" }, + { name = "packaging" }, + { name = "pygments" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pydata-sphinx-theme/pydata_sphinx_theme-0.15.4.tar.gz", hash = "sha256:7762ec0ac59df3acecf49fd2f889e1b4565dbce8b88b2e29ee06fdd90645a06d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pydata-sphinx-theme/pydata_sphinx_theme-0.15.4-py3-none-any.whl", hash = "sha256:2136ad0e9500d0949f96167e63f3e298620040aea8f9c74621959eda5d4cf8e6" }, +] + +[[package]] +name = "pygments" +version = "2.19.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pygments/pygments-2.19.2.tar.gz", hash = "sha256:636cb2477cec7f8952536970bc533bc43743542f70392ae026374600add5b887" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pygments/pygments-2.19.2-py3-none-any.whl", hash = "sha256:86540386c03d588bb81d44bc3928634ff26449851e99741617ecb9037ee5ec0b" }, +] + +[[package]] +name = "pylatexenc" +version = "2.10" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pylatexenc/pylatexenc-2.10.tar.gz", hash = "sha256:3dd8fd84eb46dc30bee1e23eaab8d8fb5a7f507347b23e5f38ad9675c84f40d3" } + +[[package]] +name = "pyparsing" +version = "3.3.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyparsing/pyparsing-3.3.2.tar.gz", hash = "sha256:c777f4d763f140633dcb6d8a3eda953bf7a214dc4eff598413c070bcdc117cbc" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyparsing/pyparsing-3.3.2-py3-none-any.whl", hash = "sha256:850ba148bd908d7e2411587e247a1e4f0327839c40e2e5e6d05a007ecc69911d" }, +] + +[[package]] +name = "python-dateutil" +version = "2.9.0.post0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "six" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/python-dateutil/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/python-dateutil/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427" }, +] + +[[package]] +name = "python-dotenv" +version = "1.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/python-dotenv/python_dotenv-1.2.1.tar.gz", hash = "sha256:42667e897e16ab0d66954af0e60a9caa94f0fd4ecf3aaf6d2d260eec1aa36ad6" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/python-dotenv/python_dotenv-1.2.1-py3-none-any.whl", hash = "sha256:b81ee9561e9ca4004139c6cbba3a238c32b03e4894671e181b671e8cb8425d61" }, +] + +[[package]] +name = "pyyaml" +version = "6.0.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-macosx_10_13_x86_64.whl", hash = "sha256:44edc647873928551a01e7a563d7452ccdebee747728c1080d881d68af7b997e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:652cb6edd41e718550aad172851962662ff2681490a8a711af6a4d288dd96824" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:10892704fc220243f5305762e276552a0395f7beb4dbf9b14ec8fd43b57f126c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:850774a7879607d3a6f50d36d04f00ee69e7fc816450e5f7e58d7f17f1ae5c00" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b8bb0864c5a28024fac8a632c443c87c5aa6f215c0b126c449ae1a150412f31d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1d37d57ad971609cf3c53ba6a7e365e40660e3be0e5175fa9f2365a379d6095a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:37503bfbfc9d2c40b344d06b2199cf0e96e97957ab1c1b546fd4f87e53e5d3e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-win32.whl", hash = "sha256:8098f252adfa6c80ab48096053f512f2321f0b998f98150cea9bd23d83e1467b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp311-cp311-win_amd64.whl", hash = "sha256:9f3bfb4965eb874431221a3ff3fdcddc7e74e3b07799e0e84ca4a0f867d449bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7f047e29dcae44602496db43be01ad42fc6f1cc0d8cd6c83d342306c32270196" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fc09d0aa354569bc501d4e787133afc08552722d3ab34836a80547331bb5d4a0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9149cad251584d5fb4981be1ecde53a1ca46c891a79788c0df828d2f166bda28" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5fdec68f91a0c6739b380c83b951e2c72ac0197ace422360e6d5a959d8d97b2c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba1cc08a7ccde2d2ec775841541641e4548226580ab850948cbfda66a1befcdc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8dc52c23056b9ddd46818a57b78404882310fb473d63f17b07d5c40421e47f8e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:41715c910c881bc081f1e8872880d3c650acf13dfa8214bad49ed4cede7c34ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-win32.whl", hash = "sha256:96b533f0e99f6579b3d4d4995707cf36df9100d67e0c8303a0c55b27b5f99bc5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-win_amd64.whl", hash = "sha256:5fcd34e47f6e0b794d17de1b4ff496c00986e1c83f7ab2fb8fcfe9616ff7477b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp312-cp312-win_arm64.whl", hash = "sha256:64386e5e707d03a7e172c0701abfb7e10f0fb753ee1d773128192742712a98fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyyaml/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b" }, +] + +[[package]] +name = "pyzmq" +version = "27.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "cffi", marker = "implementation_name == 'pypy'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:226b091818d461a3bef763805e75685e478ac17e9008f49fce2d3e52b3d58b86" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0790a0161c281ca9723f804871b4027f2e8b5a528d357c8952d08cd1a9c15581" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c895a6f35476b0c3a54e3eb6ccf41bf3018de937016e6e18748317f25d4e925f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:5bbf8d3630bf96550b3be8e1fc0fea5cbdc8d5466c1192887bd94869da17a63e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15c8bd0fe0dabf808e2d7a681398c4e5ded70a551ab47482067a572c054c8e2e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:bafcb3dd171b4ae9f19ee6380dfc71ce0390fefaf26b504c0e5f628d7c8c54f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e829529fcaa09937189178115c49c504e69289abd39967cd8a4c215761373394" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-win32.whl", hash = "sha256:6df079c47d5902af6db298ec92151db82ecb557af663098b92f2508c398bb54f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:190cbf120fbc0fc4957b56866830def56628934a9d112aec0e2507aa6a032b97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp311-cp311-win_arm64.whl", hash = "sha256:eca6b47df11a132d1745eb3b5b5e557a7dae2c303277aa0e69c6ba91b8736e07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-macosx_10_15_universal2.whl", hash = "sha256:452631b640340c928fa343801b0d07eb0c3789a5ffa843f6e1a9cee0ba4eb4fc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1c179799b118e554b66da67d88ed66cd37a169f1f23b5d9f0a231b4e8d44a113" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3837439b7f99e60312f0c926a6ad437b067356dc2bc2ec96eb395fd0fe804233" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:43ad9a73e3da1fab5b0e7e13402f0b2fb934ae1c876c51d0afff0e7c052eca31" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0de3028d69d4cdc475bfe47a6128eb38d8bc0e8f4d69646adfbcd840facbac28" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_i686.whl", hash = "sha256:cf44a7763aea9298c0aa7dbf859f87ed7012de8bda0f3977b6fb1d96745df856" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:f30f395a9e6fbca195400ce833c731e7b64c3919aa481af4d88c3759e0cb7496" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-win32.whl", hash = "sha256:250e5436a4ba13885494412b3da5d518cd0d3a278a1ae640e113c073a5f88edd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-win_amd64.whl", hash = "sha256:9ce490cf1d2ca2ad84733aa1d69ce6855372cb5ce9223802450c9b2a7cba0ccf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp312-abi3-win_arm64.whl", hash = "sha256:75a2f36223f0d535a0c919e23615fc85a1e23b71f40c7eb43d7b1dedb4d8f15f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313-android_24_arm64_v8a.whl", hash = "sha256:93ad4b0855a664229559e45c8d23797ceac03183c7b6f5b4428152a6b06684a5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313-android_24_x86_64.whl", hash = "sha256:fbb4f2400bfda24f12f009cba62ad5734148569ff4949b1b6ec3b519444342e6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-macosx_10_15_universal2.whl", hash = "sha256:e343d067f7b151cfe4eb3bb796a7752c9d369eed007b91231e817071d2c2fec7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:08363b2011dec81c354d694bdecaef4770e0ae96b9afea70b3f47b973655cc05" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d54530c8c8b5b8ddb3318f481297441af102517602b569146185fa10b63f4fa9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f3afa12c392f0a44a2414056d730eebc33ec0926aae92b5ad5cf26ebb6cc128" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c65047adafe573ff023b3187bb93faa583151627bc9c51fc4fb2c561ed689d39" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:90e6e9441c946a8b0a667356f7078d96411391a3b8f80980315455574177ec97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:add071b2d25f84e8189aaf0882d39a285b42fa3853016ebab234a5e78c7a43db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-win32.whl", hash = "sha256:7ccc0700cfdf7bd487bea8d850ec38f204478681ea02a582a8da8171b7f90a1c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:8085a9fba668216b9b4323be338ee5437a235fe275b9d1610e422ccc279733e2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp313-cp313t-win_arm64.whl", hash = "sha256:6bb54ca21bcfe361e445256c15eedf083f153811c37be87e0514934d6913061e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:ce980af330231615756acd5154f29813d553ea555485ae712c491cd483df6b7a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:1779be8c549e54a1c38f805e56d2a2e5c009d26de10921d7d51cfd1c8d4632ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7200bb0f03345515df50d99d3db206a0a6bee1955fbb8c453c76f5bf0e08fb96" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01c0e07d558b06a60773744ea6251f769cd79a41a97d11b8bf4ab8f034b0424d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:80d834abee71f65253c91540445d37c4c561e293ba6e741b992f20a105d69146" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:544b4e3b7198dde4a62b8ff6685e9802a9a1ebf47e77478a5eb88eca2a82f2fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:cedc4c68178e59a4046f97eca31b148ddcf51e88677de1ef4e78cf06c5376c9a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-win32.whl", hash = "sha256:1f0b2a577fd770aa6f053211a55d1c47901f4d537389a034c690291485e5fe92" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-win_amd64.whl", hash = "sha256:19c9468ae0437f8074af379e986c5d3d7d7bfe033506af442e8c879732bedbe0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-cp314-cp314t-win_arm64.whl", hash = "sha256:dc5dbf68a7857b59473f7df42650c621d7e8923fb03fa74a526890f4d33cc4d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:18770c8d3563715387139060d37859c02ce40718d1faf299abddcdcc6a649066" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ac25465d42f92e990f8d8b0546b01c391ad431c3bf447683fdc40565941d0604" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:53b40f8ae006f2734ee7608d59ed661419f087521edbfc2149c3932e9c14808c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-pp311-pypy311_pp73-manylinux_2_26_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f605d884e7c8be8fe1aa94e0a783bf3f591b84c24e4bc4f3e7564c82ac25e271" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/pyzmq/pyzmq-27.1.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:c9f7f6e13dff2e44a6afeaf2cf54cee5929ad64afaf4d40b50f93c58fc687355" }, +] + +[[package]] +name = "qwix" +version = "0.1.5" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "flax" }, + { name = "jax" }, + { name = "jaxlib" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/qwix/qwix-0.1.5.tar.gz", hash = "sha256:935fefd41f2b26d0fe545e433bff658b1ee476c83b7c6e467e31f769d67a74e2" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/qwix/qwix-0.1.5-py3-none-any.whl", hash = "sha256:21e71c52e22b95b3926b48b90453fcd7b9bd80f5251d52429bf36adbaffaa043" }, +] + +[[package]] +name = "referencing" +version = "0.37.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions", marker = "python_full_version < '3.13'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/referencing/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/referencing/referencing-0.37.0-py3-none-any.whl", hash = "sha256:381329a9f99628c9069361716891d34ad94af76e461dcb0335825aecc7692231" }, +] + +[[package]] +name = "regex" +version = "2026.1.15" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15.tar.gz", hash = "sha256:164759aa25575cbc0651bef59a0b18353e54300d79ace8084c818ad8ac72b7d5" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ae6020fb311f68d753b7efa9d4b9a5d47a5d6466ea0d5e3b5a471a960ea6e4a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:eddf73f41225942c1f994914742afa53dc0d01a6e20fe14b878a1b1edc74151f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e8cd52557603f5c66a548f69421310886b28b7066853089e1a71ee710e1cdc1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5170907244b14303edc5978f522f16c974f32d3aa92109fabc2af52411c9433b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2748c1ec0663580b4510bd89941a31560b4b439a0b428b49472a3d9944d11cd8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:2f2775843ca49360508d080eaa87f94fa248e2c946bbcd963bb3aae14f333413" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d9ea2604370efc9a174c1b5dcc81784fb040044232150f7f33756049edfc9026" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0dcd31594264029b57bf16f37fd7248a70b3b764ed9e0839a8f271b2d22c0785" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c08c1f3e34338256732bd6938747daa3c0d5b251e04b6e43b5813e94d503076e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e43a55f378df1e7a4fa3547c88d9a5a9b7113f653a66821bcea4718fe6c58763" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-musllinux_1_2_riscv64.whl", hash = "sha256:f82110ab962a541737bd0ce87978d4c658f06e7591ba899192e2712a517badbb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:27618391db7bdaf87ac6c92b31e8f0dfb83a9de0075855152b720140bda177a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:bfb0d6be01fbae8d6655c8ca21b3b72458606c4aec9bbc932db758d47aba6db1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-win32.whl", hash = "sha256:b10e42a6de0e32559a92f2f8dc908478cc0fa02838d7dbe764c44dca3fa13569" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-win_amd64.whl", hash = "sha256:e9bf3f0bbdb56633c07d7116ae60a576f846efdd86a8848f8d62b749e1209ca7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp311-cp311-win_arm64.whl", hash = "sha256:41aef6f953283291c4e4e6850607bd71502be67779586a61472beacb315c97ec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:4c8fcc5793dde01641a35905d6731ee1548f02b956815f8f1cab89e515a5bdf1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:bfd876041a956e6a90ad7cdb3f6a630c07d491280bfeed4544053cd434901681" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9250d087bc92b7d4899ccd5539a1b2334e44eee85d848c4c1aef8e221d3f8c8f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8a154cf6537ebbc110e24dabe53095e714245c272da9c1be05734bdad4a61aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8050ba2e3ea1d8731a549e83c18d2f0999fbc99a5f6bd06b4c91449f55291804" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf065240704cb8951cc04972cf107063917022511273e0969bdb34fc173456c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c32bef3e7aeee75746748643667668ef941d28b003bfc89994ecf09a10f7a1b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d5eaa4a4c5b1906bd0d2508d68927f15b81821f85092e06f1a34a4254b0e1af3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86c1077a3cc60d453d4084d5b9649065f3bf1184e22992bd322e1f081d3117fb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:2b091aefc05c78d286657cd4db95f2e6313375ff65dcf085e42e4c04d9c8d410" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:57e7d17f59f9ebfa9667e6e5a1c0127b96b87cb9cede8335482451ed00788ba4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:c6c4dcdfff2c08509faa15d36ba7e5ef5fcfab25f1e8f85a0c8f45bc3a30725d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:cf8ff04c642716a7f2048713ddc6278c5fd41faa3b9cab12607c7abecd012c22" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-win32.whl", hash = "sha256:82345326b1d8d56afbe41d881fdf62f1926d7264b2fc1537f99ae5da9aad7913" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-win_amd64.whl", hash = "sha256:4def140aa6156bc64ee9912383d4038f3fdd18fee03a6f222abd4de6357ce42a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp312-cp312-win_arm64.whl", hash = "sha256:c6c565d9a6e1a8d783c1948937ffc377dd5771e83bd56de8317c450a954d2056" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:e69d0deeb977ffe7ed3d2e4439360089f9c3f217ada608f0f88ebd67afb6385e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3601ffb5375de85a16f407854d11cca8fe3f5febbe3ac78fb2866bb220c74d10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4c5ef43b5c2d4114eb8ea424bb8c9cec01d5d17f242af88b2448f5ee81caadbc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:968c14d4f03e10b2fd960f1d5168c1f0ac969381d3c1fcc973bc45fb06346599" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:56a5595d0f892f214609c9f76b41b7428bed439d98dc961efafdd1354d42baae" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0bf650f26087363434c4e560011f8e4e738f6f3e029b85d4904c50135b86cfa5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18388a62989c72ac24de75f1449d0fb0b04dfccd0a1a7c1c43af5eb503d890f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:6d220a2517f5893f55daac983bfa9fe998a7dbcaee4f5d27a88500f8b7873788" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c9c08c2fbc6120e70abff5d7f28ffb4d969e14294fb2143b4b5c7d20e46d1714" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7ef7d5d4bd49ec7364315167a4134a015f61e8266c6d446fc116a9ac4456e10d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:6e42844ad64194fa08d5ccb75fe6a459b9b08e6d7296bd704460168d58a388f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:cfecdaa4b19f9ca534746eb3b55a5195d5c95b88cac32a205e981ec0a22b7d31" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:08df9722d9b87834a3d701f3fca570b2be115654dbfd30179f30ab2f39d606d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-win32.whl", hash = "sha256:d426616dae0967ca225ab12c22274eb816558f2f99ccb4a1d52ca92e8baf180f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-win_amd64.whl", hash = "sha256:febd38857b09867d3ed3f4f1af7d241c5c50362e25ef43034995b77a50df494e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313-win_arm64.whl", hash = "sha256:8e32f7896f83774f91499d239e24cebfadbc07639c1494bb7213983842348337" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ec94c04149b6a7b8120f9f44565722c7ae31b7a6d2275569d2eefa76b83da3be" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:40c86d8046915bb9aeb15d3f3f15b6fd500b8ea4485b30e1bbc799dab3fe29f8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:726ea4e727aba21643205edad8f2187ec682d3305d790f73b7a51c7587b64bdd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1cb740d044aff31898804e7bf1181cc72c03d11dfd19932b9911ffc19a79070a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05d75a668e9ea16f832390d22131fe1e8acc8389a694c8febc3e340b0f810b93" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d991483606f3dbec93287b9f35596f41aa2e92b7c2ebbb935b63f409e243c9af" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:194312a14819d3e44628a44ed6fea6898fdbecb0550089d84c403475138d0a09" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:fe2fda4110a3d0bc163c2e0664be44657431440722c5c5315c65155cab92f9e5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:124dc36c85d34ef2d9164da41a53c1c8c122cfb1f6e1ec377a1f27ee81deb794" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:a1774cd1981cd212506a23a14dba7fdeaee259f5deba2df6229966d9911e767a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-musllinux_1_2_riscv64.whl", hash = "sha256:b5f7d8d2867152cdb625e72a530d2ccb48a3d199159144cbdd63870882fb6f80" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:492534a0ab925d1db998defc3c302dae3616a2fc3fe2e08db1472348f096ddf2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:c661fc820cfb33e166bf2450d3dadbda47c8d8981898adb9b6fe24e5e582ba60" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-win32.whl", hash = "sha256:99ad739c3686085e614bf77a508e26954ff1b8f14da0e3765ff7abbf7799f952" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-win_amd64.whl", hash = "sha256:32655d17905e7ff8ba5c764c43cb124e34a9245e45b83c22e81041e1071aee10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp313-cp313t-win_arm64.whl", hash = "sha256:b2a13dd6a95e95a489ca242319d18fc02e07ceb28fa9ad146385194d95b3c829" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:d920392a6b1f353f4aa54328c867fec3320fa50657e25f64abf17af054fc97ac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b5a28980a926fa810dbbed059547b02783952e2efd9c636412345232ddb87ff6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:621f73a07595d83f28952d7bd1e91e9d1ed7625fb7af0064d3516674ec93a2a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3d7d92495f47567a9b1669c51fc8d6d809821849063d168121ef801bbc213846" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:8dd16fba2758db7a3780a051f245539c4451ca20910f5a5e6ea1c08d06d4a76b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1e1808471fbe44c1a63e5f577a1d5f02fe5d66031dcbdf12f093ffc1305a858e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0751a26ad39d4f2ade8fe16c59b2bf5cb19eb3d2cd543e709e583d559bd9efde" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:0f0c7684c7f9ca241344ff95a1de964f257a5251968484270e91c25a755532c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:74f45d170a21df41508cb67165456538425185baaf686281fa210d7e729abc34" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1862739a1ffb50615c0fde6bae6569b5efbe08d98e59ce009f68a336f64da75" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:453078802f1b9e2b7303fb79222c054cb18e76f7bdc220f7530fdc85d319f99e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:a30a68e89e5a218b8b23a52292924c1f4b245cb0c68d1cce9aec9bbda6e2c160" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9479cae874c81bf610d72b85bb681a94c95722c127b55445285fb0e2c82db8e1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-win32.whl", hash = "sha256:d639a750223132afbfb8f429c60d9d318aeba03281a5f1ab49f877456448dcf1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-win_amd64.whl", hash = "sha256:4161d87f85fa831e31469bfd82c186923070fc970b9de75339b68f0c75b51903" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314-win_arm64.whl", hash = "sha256:91c5036ebb62663a6b3999bdd2e559fd8456d17e2b485bf509784cd31a8b1705" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:ee6854c9000a10938c79238de2379bea30c82e4925a371711af45387df35cab8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:2c2b80399a422348ce5de4fe40c418d6299a0fa2803dd61dc0b1a2f28e280fcf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:dca3582bca82596609959ac39e12b7dad98385b4fefccb1151b937383cec547d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ef71d476caa6692eea743ae5ea23cde3260677f70122c4d258ca952e5c2d4e84" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c243da3436354f4af6c3058a3f81a97d47ea52c9bd874b52fd30274853a1d5df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8355ad842a7c7e9e5e55653eade3b7d1885ba86f124dd8ab1f722f9be6627434" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f192a831d9575271a22d804ff1a5355355723f94f31d9eef25f0d45a152fdc1a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:166551807ec20d47ceaeec380081f843e88c8949780cd42c40f18d16168bed10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:f9ca1cbdc0fbfe5e6e6f8221ef2309988db5bcede52443aeaee9a4ad555e0dac" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b30bcbd1e1221783c721483953d9e4f3ab9c5d165aa709693d3f3946747b1aea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:2a8d7b50c34578d0d3bf7ad58cde9652b7d683691876f83aedc002862a35dc5e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:9d787e3310c6a6425eb346be4ff2ccf6eece63017916fd77fe8328c57be83521" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:619843841e220adca114118533a574a9cd183ed8a28b85627d2844c500a2b0db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-win32.whl", hash = "sha256:e90b8db97f6f2c97eb045b51a6b2c5ed69cedd8392459e0642d4199b94fabd7e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-win_amd64.whl", hash = "sha256:5ef19071f4ac9f0834793af85bd04a920b4407715624e40cb7a0631a11137cdf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/regex/regex-2026.1.15-cp314-cp314t-win_arm64.whl", hash = "sha256:ca89c5e596fc05b015f27561b3793dc2fa0917ea0d7507eebb448efd35274a70" }, +] + +[[package]] +name = "requests" +version = "2.32.5" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/requests/requests-2.32.5.tar.gz", hash = "sha256:dbba0bac56e100853db0ea71b82b4dfd5fe2bf6d3754a8893c3af500cec7d7cf" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/requests/requests-2.32.5-py3-none-any.whl", hash = "sha256:2462f94637a34fd532264295e186976db0f5d453d1cdd31473c85a6a161affb6" }, +] + +[[package]] +name = "rich" +version = "14.3.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "markdown-it-py" }, + { name = "pygments" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rich/rich-14.3.2.tar.gz", hash = "sha256:e712f11c1a562a11843306f5ed999475f09ac31ffb64281f73ab29ffdda8b3b8" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rich/rich-14.3.2-py3-none-any.whl", hash = "sha256:08e67c3e90884651da3239ea668222d19bea7b589149d8014a21c633420dbb69" }, +] + +[[package]] +name = "roman-numerals" +version = "4.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/roman-numerals/roman_numerals-4.1.0.tar.gz", hash = "sha256:1af8b147eb1405d5839e78aeb93131690495fe9da5c91856cb33ad55a7f1e5b2" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/roman-numerals/roman_numerals-4.1.0-py3-none-any.whl", hash = "sha256:647ba99caddc2cc1e55a51e4360689115551bf4476d90e8162cf8c345fe233c7" }, +] + +[[package]] +name = "rpds-py" +version = "0.30.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0.tar.gz", hash = "sha256:dd8ff7cf90014af0c0f787eea34794ebf6415242ee1d6fa91eaba725cc441e84" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:a2bffea6a4ca9f01b3f8e548302470306689684e61602aa3d141e34da06cf425" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dc4f992dfe1e2bc3ebc7444f6c7051b4bc13cd8e33e43511e8ffd13bf407010d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:422c3cb9856d80b09d30d2eb255d0754b23e090034e1deb4083f8004bd0761e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:07ae8a593e1c3c6b82ca3292efbe73c30b61332fd612e05abee07c79359f292f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12f90dd7557b6bd57f40abe7747e81e0c0b119bef015ea7726e69fe550e394a4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:99b47d6ad9a6da00bec6aabe5a6279ecd3c06a329d4aa4771034a21e335c3a97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33f559f3104504506a44bb666b93a33f5d33133765b0c216a5bf2f1e1503af89" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_31_riscv64.whl", hash = "sha256:946fe926af6e44f3697abbc305ea168c2c31d3e3ef1058cf68f379bf0335a78d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:495aeca4b93d465efde585977365187149e75383ad2684f81519f504f5c13038" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d9a0ca5da0386dee0655b4ccdf46119df60e0f10da268d04fe7cc87886872ba7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8d6d1cc13664ec13c1b84241204ff3b12f9bb82464b8ad6e7a5d3486975c2eed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3896fa1be39912cf0757753826bc8bdc8ca331a28a7c4ae46b7a21280b06bb85" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-win32.whl", hash = "sha256:55f66022632205940f1827effeff17c4fa7ae1953d2b74a8581baaefb7d16f8c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-win_amd64.whl", hash = "sha256:a51033ff701fca756439d641c0ad09a41d9242fa69121c7d8769604a0a629825" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp311-cp311-win_arm64.whl", hash = "sha256:47b0ef6231c58f506ef0b74d44e330405caa8428e770fec25329ed2cb971a229" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:a161f20d9a43006833cd7068375a94d035714d73a172b681d8881820600abfad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6abc8880d9d036ecaafe709079969f56e876fcf107f7a8e9920ba6d5a3878d05" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca28829ae5f5d569bb62a79512c842a03a12576375d5ece7d2cadf8abe96ec28" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a1010ed9524c73b94d15919ca4d41d8780980e1765babf85f9a2f90d247153dd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f8d1736cfb49381ba528cd5baa46f82fdc65c06e843dab24dd70b63d09121b3f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d948b135c4693daff7bc2dcfc4ec57237a29bd37e60c2fabf5aff2bbacf3e2f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47f236970bccb2233267d89173d3ad2703cd36a0e2a6e92d0560d333871a3d23" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_31_riscv64.whl", hash = "sha256:2e6ecb5a5bcacf59c3f912155044479af1d0b6681280048b338b28e364aca1f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a8fa71a2e078c527c3e9dc9fc5a98c9db40bcc8a92b4e8858e36d329f8684b51" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73c67f2db7bc334e518d097c6d1e6fed021bbc9b7d678d6cc433478365d1d5f5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5ba103fb455be00f3b1c2076c9d4264bfcb037c976167a6047ed82f23153f02e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7cee9c752c0364588353e627da8a7e808a66873672bcb5f52890c33fd965b394" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-win32.whl", hash = "sha256:1ab5b83dbcf55acc8b08fc62b796ef672c457b17dbd7820a11d6c52c06839bdf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-win_amd64.whl", hash = "sha256:a090322ca841abd453d43456ac34db46e8b05fd9b3b4ac0c78bcde8b089f959b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp312-cp312-win_arm64.whl", hash = "sha256:669b1805bd639dd2989b281be2cfd951c6121b65e729d9b843e9639ef1fd555e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:f83424d738204d9770830d35290ff3273fbb02b41f919870479fab14b9d303b2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7536cd91353c5273434b4e003cbda89034d67e7710eab8761fd918ec6c69cf8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2771c6c15973347f50fece41fc447c054b7ac2ae0502388ce3b6738cd366e3d4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0a59119fc6e3f460315fe9d08149f8102aa322299deaa5cab5b40092345c2136" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:76fec018282b4ead0364022e3c54b60bf368b9d926877957a8624b58419169b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:692bef75a5525db97318e8cd061542b5a79812d711ea03dbc1f6f8dbb0c5f0d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9027da1ce107104c50c81383cae773ef5c24d296dd11c99e2629dbd7967a20c6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:9cf69cdda1f5968a30a359aba2f7f9aa648a9ce4b580d6826437f2b291cfc86e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a4796a717bf12b9da9d3ad002519a86063dcac8988b030e405704ef7d74d2d9d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5d4c2aa7c50ad4728a094ebd5eb46c452e9cb7edbfdb18f9e1221f597a73e1e7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba81a9203d07805435eb06f536d95a266c21e5b2dfbf6517748ca40c98d19e31" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:945dccface01af02675628334f7cf49c2af4c1c904748efc5cf7bbdf0b579f95" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-win32.whl", hash = "sha256:b40fb160a2db369a194cb27943582b38f79fc4887291417685f3ad693c5a1d5d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-win_amd64.whl", hash = "sha256:806f36b1b605e2d6a72716f321f20036b9489d29c51c91f4dd29a3e3afb73b15" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313-win_arm64.whl", hash = "sha256:d96c2086587c7c30d44f31f42eae4eac89b60dabbac18c7669be3700f13c3ce1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:eb0b93f2e5c2189ee831ee43f156ed34e2a89a78a66b98cadad955972548be5a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:922e10f31f303c7c920da8981051ff6d8c1a56207dbdf330d9047f6d30b70e5e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cdc62c8286ba9bf7f47befdcea13ea0e26bf294bda99758fd90535cbaf408000" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:47f9a91efc418b54fb8190a6b4aa7813a23fb79c51f4bb84e418f5476c38b8db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1f3587eb9b17f3789ad50824084fa6f81921bbf9a795826570bda82cb3ed91f2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:39c02563fc592411c2c61d26b6c5fe1e51eaa44a75aa2c8735ca88b0d9599daa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51a1234d8febafdfd33a42d97da7a43f5dcb120c1060e352a3fbc0c6d36e2083" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_31_riscv64.whl", hash = "sha256:eb2c4071ab598733724c08221091e8d80e89064cd472819285a9ab0f24bcedb9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6bdfdb946967d816e6adf9a3d8201bfad269c67efe6cefd7093ef959683c8de0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:c77afbd5f5250bf27bf516c7c4a016813eb2d3e116139aed0096940c5982da94" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:61046904275472a76c8c90c9ccee9013d70a6d0f73eecefd38c1ae7c39045a08" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:4c5f36a861bc4b7da6516dbdf302c55313afa09b81931e8280361a4f6c9a2d27" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-win32.whl", hash = "sha256:3d4a69de7a3e50ffc214ae16d79d8fbb0922972da0356dcf4d0fdca2878559c6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp313-cp313t-win_amd64.whl", hash = "sha256:f14fc5df50a716f7ece6a80b6c78bb35ea2ca47c499e422aa4463455dd96d56d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:68f19c879420aa08f61203801423f6cd5ac5f0ac4ac82a2368a9fcd6a9a075e0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ec7c4490c672c1a0389d319b3a9cfcd098dcdc4783991553c332a15acf7249be" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f251c812357a3fed308d684a5079ddfb9d933860fc6de89f2b7ab00da481e65f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:ac98b175585ecf4c0348fd7b29c3864bda53b805c773cbf7bfdaffc8070c976f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3e62880792319dbeb7eb866547f2e35973289e7d5696c6e295476448f5b63c87" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4e7fc54e0900ab35d041b0601431b0a0eb495f0851a0639b6ef90f7741b39a18" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:47e77dc9822d3ad616c3d5759ea5631a75e5809d5a28707744ef79d7a1bcfcad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:b4dc1a6ff022ff85ecafef7979a2c6eb423430e05f1165d6688234e62ba99a07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4559c972db3a360808309e06a74628b95eaccbf961c335c8fe0d590cf587456f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ed177ed9bded28f8deb6ab40c183cd1192aa0de40c12f38be4d59cd33cb5c65" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:ad1fa8db769b76ea911cb4e10f049d80bf518c104f15b3edb2371cc65375c46f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:46e83c697b1f1c72b50e5ee5adb4353eef7406fb3f2043d64c33f20ad1c2fc53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-win32.whl", hash = "sha256:ee454b2a007d57363c2dfd5b6ca4a5d7e2c518938f8ed3b706e37e5d470801ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-win_amd64.whl", hash = "sha256:95f0802447ac2d10bcc69f6dc28fe95fdf17940367b21d34e34c737870758950" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314-win_arm64.whl", hash = "sha256:613aa4771c99f03346e54c3f038e4cc574ac09a3ddfb0e8878487335e96dead6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:7e6ecfcb62edfd632e56983964e6884851786443739dbfe3582947e87274f7cb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:a1d0bc22a7cdc173fedebb73ef81e07faef93692b8c1ad3733b67e31e1b6e1b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d08f00679177226c4cb8c5265012eea897c8ca3b93f429e546600c971bcbae7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:5965af57d5848192c13534f90f9dd16464f3c37aaf166cc1da1cae1fd5a34898" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9a4e86e34e9ab6b667c27f3211ca48f73dba7cd3d90f8d5b11be56e5dbc3fb4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e5d3e6b26f2c785d65cc25ef1e5267ccbe1b069c5c21b8cc724efee290554419" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:626a7433c34566535b6e56a1b39a7b17ba961e97ce3b80ec62e6f1312c025551" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:acd7eb3f4471577b9b5a41baf02a978e8bdeb08b4b355273994f8b87032000a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:fe5fa731a1fa8a0a56b0977413f8cacac1768dad38d16b3a296712709476fbd5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:74a3243a411126362712ee1524dfc90c650a503502f135d54d1b352bd01f2404" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:3e8eeb0544f2eb0d2581774be4c3410356eba189529a6b3e36bbbf9696175856" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:dbd936cde57abfee19ab3213cf9c26be06d60750e60a8e4dd85d1ab12c8b1f40" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-win32.whl", hash = "sha256:dc824125c72246d924f7f796b4f63c1e9dc810c7d9e2355864b3c3a73d59ade0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-cp314-cp314t-win_amd64.whl", hash = "sha256:27f4b0e92de5bfbc6f86e43959e6edd1425c33b5e69aab0984a72047f2bcf1e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c2262bdba0ad4fc6fb5545660673925c2d2a5d9e2e0fb603aad545427be0fc58" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:ee6af14263f25eedc3bb918a3c04245106a42dfd4f5c2285ea6f997b1fc3f89a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3adbb8179ce342d235c31ab8ec511e66c73faa27a47e076ccc92421add53e2bb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:250fa00e9543ac9b97ac258bd37367ff5256666122c2d0f2bc97577c60a1818c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9854cf4f488b3d57b9aaeb105f06d78e5529d3145b1e4a41750167e8c213c6d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:993914b8e560023bc0a8bf742c5f303551992dcb85e247b1e5c7f4a7d145bda5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58edca431fb9b29950807e301826586e5bbf24163677732429770a697ffe6738" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_31_riscv64.whl", hash = "sha256:dea5b552272a944763b34394d04577cf0f9bd013207bc32323b5a89a53cf9c2f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ba3af48635eb83d03f6c9735dfb21785303e73d22ad03d489e88adae6eab8877" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:dff13836529b921e22f15cb099751209a60009731a68519630a24d61f0b1b30a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1b151685b23929ab7beec71080a8889d4d6d9fa9a983d213f07121205d48e2c4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/rpds-py/rpds_py-0.30.0-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:ac37f9f516c51e5753f27dfdef11a88330f04de2d564be3991384b2f3535d02e" }, +] + +[[package]] +name = "safetensors" +version = "0.7.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0.tar.gz", hash = "sha256:07663963b67e8bd9f0b8ad15bb9163606cd27cc5a1b96235a50d8369803b96b0" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:c82f4d474cf725255d9e6acf17252991c3c8aac038d6ef363a4bf8be2f6db517" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:94fd4858284736bb67a897a41608b5b0c2496c9bdb3bf2af1fa3409127f20d57" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e07d91d0c92a31200f25351f4acb2bc6aff7f48094e13ebb1d0fb995b54b6542" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8469155f4cb518bafb4acf4865e8bb9d6804110d2d9bdcaa78564b9fd841e104" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:54bef08bf00a2bff599982f6b08e8770e09cc012d7bba00783fc7ea38f1fb37d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:42cb091236206bb2016d245c377ed383aa7f78691748f3bb6ee1bfa51ae2ce6a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dac7252938f0696ddea46f5e855dd3138444e82236e3be475f54929f0c510d48" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1d060c70284127fa805085d8f10fbd0962792aed71879d00864acda69dbab981" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:cdab83a366799fa730f90a4ebb563e494f28e9e92c4819e556152ad55e43591b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:672132907fcad9f2aedcb705b2d7b3b93354a2aec1b2f706c4db852abe338f85" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:5d72abdb8a4d56d4020713724ba81dac065fedb7f3667151c4a637f1d3fb26c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b0f6d66c1c538d5a94a73aa9ddca8ccc4227e6c9ff555322ea40bdd142391dd4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-win32.whl", hash = "sha256:c74af94bf3ac15ac4d0f2a7c7b4663a15f8c2ab15ed0fc7531ca61d0835eccba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/safetensors/safetensors-0.7.0-cp38-abi3-win_amd64.whl", hash = "sha256:d1239932053f56f3456f32eb9625590cc7582e905021f94636202a864d470755" }, +] + +[[package]] +name = "scipy" +version = "1.17.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0.tar.gz", hash = "sha256:2591060c8e648d8b96439e111ac41fd8342fdeff1876be2e19dea3fe8930454e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:2abd71643797bd8a106dff97894ff7869eeeb0af0f7a5ce02e4227c6a2e9d6fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:ef28d815f4d2686503e5f4f00edc387ae58dfd7a2f42e348bb53359538f01558" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:272a9f16d6bb4667e8b50d25d71eddcc2158a214df1b566319298de0939d2ab7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:7204fddcbec2fe6598f1c5fdf027e9f259106d05202a959a9f1aecf036adc9f6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fc02c37a5639ee67d8fb646ffded6d793c06c5622d36b35cfa8fe5ececb8f042" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dac97a27520d66c12a34fd90a4fe65f43766c18c0d6e1c0a80f114d2260080e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:ebb7446a39b3ae0fe8f416a9a3fdc6fba3f11c634f680f16a239c5187bc487c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:474da16199f6af66601a01546144922ce402cb17362e07d82f5a6cf8f963e449" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:255c0da161bd7b32a6c898e7891509e8a9289f0b1c6c7d96142ee0d2b114c2ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp311-cp311-win_arm64.whl", hash = "sha256:85b0ac3ad17fa3be50abd7e69d583d98792d7edc08367e01445a1e2076005379" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:0d5018a57c24cb1dd828bcf51d7b10e65986d549f52ef5adb6b4d1ded3e32a57" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:88c22af9e5d5a4f9e027e26772cc7b5922fab8bcc839edb3ae33de404feebd9e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:f3cd947f20fe17013d401b64e857c6b2da83cae567adbb75b9dcba865abc66d8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:e8c0b331c2c1f531eb51f1b4fc9ba709521a712cce58f1aa627bc007421a5306" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5194c445d0a1c7a6c1a4a4681b6b7c71baad98ff66d96b949097e7513c9d6742" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9eeb9b5f5997f75507814ed9d298ab23f62cf79f5a3ef90031b1ee2506abdb5b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:40052543f7bbe921df4408f46003d6f01c6af109b9e2c8a66dd1cf6cf57f7d5d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0cf46c8013fec9d3694dc572f0b54100c28405d55d3e2cb15e2895b25057996e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:0937a0b0d8d593a198cededd4c439a0ea216a3f36653901ea1f3e4be949056f8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp312-cp312-win_arm64.whl", hash = "sha256:f603d8a5518c7426414d1d8f82e253e454471de682ce5e39c29adb0df1efb86b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:65ec32f3d32dfc48c72df4291345dae4f048749bc8d5203ee0a3f347f96c5ce6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-macosx_12_0_arm64.whl", hash = "sha256:1f9586a58039d7229ce77b52f8472c972448cded5736eaf102d5658bbac4c269" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:9fad7d3578c877d606b1150135c2639e9de9cecd3705caa37b66862977cc3e72" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:423ca1f6584fc03936972b5f7c06961670dbba9f234e71676a7c7ccf938a0d61" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe508b5690e9eaaa9467fc047f833af58f1152ae51a0d0aed67aa5801f4dd7d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6680f2dfd4f6182e7d6db161344537da644d1cf85cf293f015c60a17ecf08752" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:eec3842ec9ac9de5917899b277428886042a93db0b227ebbe3a333b64ec7643d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d7425fcafbc09a03731e1bc05581f5fad988e48c6a861f441b7ab729a49a55ea" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-win_amd64.whl", hash = "sha256:87b411e42b425b84777718cc41516b8a7e0795abfa8e8e1d573bf0ef014f0812" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313-win_arm64.whl", hash = "sha256:357ca001c6e37601066092e7c89cca2f1ce74e2a520ca78d063a6d2201101df2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-macosx_10_14_x86_64.whl", hash = "sha256:ec0827aa4d36cb79ff1b81de898e948a51ac0b9b1c43e4a372c0508c38c0f9a3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-macosx_12_0_arm64.whl", hash = "sha256:819fc26862b4b3c73a60d486dbb919202f3d6d98c87cf20c223511429f2d1a97" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:363ad4ae2853d88ebcde3ae6ec46ccca903ea9835ee8ba543f12f575e7b07e4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:979c3a0ff8e5ba254d45d59ebd38cde48fce4f10b5125c680c7a4bfe177aab07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:130d12926ae34399d157de777472bf82e9061c60cc081372b3118edacafe1d00" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6e886000eb4919eae3a44f035e63f0fd8b651234117e8f6f29bad1cd26e7bc45" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:13c4096ac6bc31d706018f06a49abe0485f96499deb82066b94d19b02f664209" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:cacbaddd91fcffde703934897c5cd2c7cb0371fac195d383f4e1f1c5d3f3bd04" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-win_amd64.whl", hash = "sha256:edce1a1cf66298cccdc48a1bdf8fb10a3bf58e8b58d6c3883dd1530e103f87c0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp313-cp313t-win_arm64.whl", hash = "sha256:30509da9dbec1c2ed8f168b8d8aa853bc6723fede1dbc23c7d43a56f5ab72a67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-macosx_10_14_x86_64.whl", hash = "sha256:c17514d11b78be8f7e6331b983a65a7f5ca1fd037b95e27b280921fe5606286a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-macosx_12_0_arm64.whl", hash = "sha256:4e00562e519c09da34c31685f6acc3aa384d4d50604db0f245c14e1b4488bfa2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:f7df7941d71314e60a481e02d5ebcb3f0185b8d799c70d03d8258f6c80f3d467" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:aabf057c632798832f071a8dde013c2e26284043934f53b00489f1773b33527e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a38c3337e00be6fd8a95b4ed66b5d988bac4ec888fd922c2ea9fe5fb1603dd67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00fb5f8ec8398ad90215008d8b6009c9db9fa924fd4c7d6be307c6f945f9cd73" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f2a4942b0f5f7c23c7cd641a0ca1955e2ae83dedcff537e3a0259096635e186b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:dbf133ced83889583156566d2bdf7a07ff89228fe0c0cb727f777de92092ec6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-win_amd64.whl", hash = "sha256:3625c631a7acd7cfd929e4e31d2582cf00f42fcf06011f59281271746d77e061" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314-win_arm64.whl", hash = "sha256:9244608d27eafe02b20558523ba57f15c689357c85bdcfe920b1828750aa26eb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-macosx_10_14_x86_64.whl", hash = "sha256:2b531f57e09c946f56ad0b4a3b2abee778789097871fc541e267d2eca081cff1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-macosx_12_0_arm64.whl", hash = "sha256:13e861634a2c480bd237deb69333ac79ea1941b94568d4b0efa5db5e263d4fd1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:eb2651271135154aa24f6481cbae5cc8af1f0dd46e6533fb7b56aa9727b6a232" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:c5e8647f60679790c2f5c76be17e2e9247dc6b98ad0d3b065861e082c56e078d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5fb10d17e649e1446410895639f3385fd2bf4c3c7dfc9bea937bddcbc3d7b9ba" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8547e7c57f932e7354a2319fab613981cde910631979f74c9b542bb167a8b9db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33af70d040e8af9d5e7a38b5ed3b772adddd281e3062ff23fec49e49681c38cf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb55bb97d00f8b7ab95cb64f873eb0bf54d9446264d9f3609130381233483f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-win_amd64.whl", hash = "sha256:1ff269abf702f6c7e67a4b7aad981d42871a11b9dd83c58d2d2ea624efbd1088" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/scipy/scipy-1.17.0-cp314-cp314t-win_arm64.whl", hash = "sha256:031121914e295d9791319a1875444d55079885bbae5bdc9c5e0f2ee5f09d34ff" }, +] + +[[package]] +name = "sentencepiece" +version = "0.2.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1.tar.gz", hash = "sha256:8138cec27c2f2282f4a34d9a016e3374cd40e5c6e9cb335063db66a0a3b71fad" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:6356d0986b8b8dc351b943150fcd81a1c6e6e4d439772e8584c64230e58ca987" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8f8ba89a3acb3dc1ae90f65ec1894b0b9596fdb98ab003ff38e058f898b39bc7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:02593eca45440ef39247cee8c47322a34bdcc1d8ae83ad28ba5a899a2cf8d79a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a0d15781a171d188b661ae4bde1d998c303f6bd8621498c50c671bd45a4798e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4f5a3e0d9f445ed9d66c0fec47d4b23d12cfc858b407a03c194c1b26c2ac2a63" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-win32.whl", hash = "sha256:6d297a1748d429ba8534eebe5535448d78b8acc32d00a29b49acf28102eeb094" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:82d9ead6591015f009cb1be1cb1c015d5e6f04046dbb8c9588b931e869a29728" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp311-cp311-win_arm64.whl", hash = "sha256:39f8651bd10974eafb9834ce30d9bcf5b73e1fc798a7f7d2528f9820ca86e119" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:57cae326c8727de58c85977b175af132a7138d84c764635d7e71bbee7e774133" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:56dd39a3c4d6493db3cdca7e8cc68c6b633f0d4195495cbadfcf5af8a22d05a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d9381351182ff9888cc80e41c632e7e274b106f450de33d67a9e8f6043da6f76" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:99f955df238021bf11f0fc37cdb54fd5e5b5f7fd30ecc3d93fb48b6815437167" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0cdfecef430d985f1c2bcbfff3defd1d95dae876fbd0173376012d2d7d24044b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-win32.whl", hash = "sha256:a483fd29a34c3e34c39ac5556b0a90942bec253d260235729e50976f5dba1068" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:4cdc7c36234fda305e85c32949c5211faaf8dd886096c7cea289ddc12a2d02de" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp312-cp312-win_arm64.whl", hash = "sha256:daeb5e9e9fcad012324807856113708614d534f596d5008638eb9b40112cd9e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:dcd8161eee7b41aae57ded06272905dbd680a0a04b91edd0f64790c796b2f706" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:c6c8f42949f419ff8c7e9960dbadcfbc982d7b5efc2f6748210d3dd53a7de062" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:097f3394e99456e9e4efba1737c3749d7e23563dd1588ce71a3d007f25475fff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d7b670879c370d350557edabadbad1f6561a9e6968126e6debca4029e5547820" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c7f0fd2f2693309e6628aeeb2e2faf6edd221134dfccac3308ca0de01f8dab47" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-win32.whl", hash = "sha256:92b3816aa2339355fda2c8c4e021a5de92180b00aaccaf5e2808972e77a4b22f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:10ed3dab2044c47f7a2e7b4969b0c430420cdd45735d78c8f853191fa0e3148b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac650534e2251083c5f75dde4ff28896ce7c8904133dc8fef42780f4d5588fcd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:8dd4b477a7b069648d19363aad0cab9bad2f4e83b2d179be668efa672500dc94" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c0f672da370cc490e4c59d89e12289778310a0e71d176c541e4834759e1ae07" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ad8493bea8432dae8d6830365352350f3b4144415a1d09c4c8cb8d30cf3b6c3c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b81a24733726e3678d2db63619acc5a8dccd074f7aa7a54ecd5ca33ca6d2d596" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0a81799d0a68d618e89063fb423c3001a034c893069135ffe51fee439ae474d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-win32.whl", hash = "sha256:89a3ea015517c42c0341d0d962f3e6aaf2cf10d71b1932d475c44ba48d00aa2b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:33f068c9382dc2e7c228eedfd8163b52baa86bb92f50d0488bf2b7da7032e484" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:b3616ad246f360e52c85781e47682d31abfb6554c779e42b65333d4b5f44ecc0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:5d0350b686c320068702116276cfb26c066dc7e65cfef173980b11bb4d606719" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c7f54a31cde6fa5cb030370566f68152a742f433f8d2be458463d06c208aef33" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:c83b85ab2d6576607f31df77ff86f28182be4a8de6d175d2c33ca609925f5da1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1855f57db07b51fb51ed6c9c452f570624d2b169b36f0f79ef71a6e6c618cd8b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:01e6912125cb45d3792f530a4d38f8e21bf884d6b4d4ade1b2de5cf7a8d2a52b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-win32.whl", hash = "sha256:c415c9de1447e0a74ae3fdb2e52f967cb544113a3a5ce3a194df185cbc1f962f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-win_amd64.whl", hash = "sha256:881b2e44b14fc19feade3cbed314be37de639fc415375cefaa5bc81a4be137fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314-win_arm64.whl", hash = "sha256:2005242a16d2dc3ac5fe18aa7667549134d37854823df4c4db244752453b78a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:a19adcec27c524cb7069a1c741060add95f942d1cbf7ad0d104dffa0a7d28a2b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:e37e4b4c4a11662b5db521def4e44d4d30ae69a1743241412a93ae40fdcab4bb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:477c81505db072b3ab627e7eab972ea1025331bd3a92bacbf798df2b75ea86ec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:010f025a544ef770bb395091d57cb94deb9652d8972e0d09f71d85d5a0816c8c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:733e59ff1794d26db706cd41fc2d7ca5f6c64a820709cb801dc0ea31780d64ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-win32.whl", hash = "sha256:d3233770f78e637dc8b1fda2cd7c3b99ec77e7505041934188a4e7fe751de3b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-win_amd64.whl", hash = "sha256:5e4366c97b68218fd30ea72d70c525e6e78a6c0a88650f57ac4c43c63b234a9d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sentencepiece/sentencepiece-0.2.1-cp314-cp314t-win_arm64.whl", hash = "sha256:105e36e75cbac1292642045458e8da677b2342dcd33df503e640f0b457cb6751" }, +] + +[[package]] +name = "simple-parsing" +version = "0.1.8" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "docstring-parser" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple-parsing/simple_parsing-0.1.8.tar.gz", hash = "sha256:19c2a9002ebd7ad281fce579f9b2a0aa0c4d67e1688cee0e8cdf6d8e98ec2c18" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple-parsing/simple_parsing-0.1.8-py3-none-any.whl", hash = "sha256:4d1ef136a28674b3ebb9760cacda4d6f01de32de0b280a869df977d182f12947" }, +] + +[[package]] +name = "simplejson" +version = "3.20.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2.tar.gz", hash = "sha256:5fe7a6ce14d1c300d80d08695b7f7e633de6cd72c80644021874d985b3393649" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:06190b33cd7849efc413a5738d3da00b90e4a5382fd3d584c841ac20fb828c6f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4ad4eac7d858947a30d2c404e61f16b84d16be79eb6fb316341885bdde864fa8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:b392e11c6165d4a0fde41754a0e13e1d88a5ad782b245a973dd4b2bdb4e5076a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:51eccc4e353eed3c50e0ea2326173acdc05e58f0c110405920b989d481287e51" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:306e83d7c331ad833d2d43c76a67f476c4b80c4a13334f6e34bb110e6105b3bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f820a6ac2ef0bc338ae4963f4f82ccebdb0824fe9caf6d660670c578abe01013" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21e7a066528a5451433eb3418184f05682ea0493d14e9aae690499b7e1eb6b81" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:438680ddde57ea87161a4824e8de04387b328ad51cfdf1eaf723623a3014b7aa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:cac78470ae68b8d8c41b6fca97f5bf8e024ca80d5878c7724e024540f5cdaadb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:7524e19c2da5ef281860a3d74668050c6986be15c9dd99966034ba47c68828c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0e9b6d845a603b2eef3394eb5e21edb8626cd9ae9a8361d14e267eb969dbe413" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-win32.whl", hash = "sha256:47d8927e5ac927fdd34c99cc617938abb3624b06ff86e8e219740a86507eb961" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp311-cp311-win_amd64.whl", hash = "sha256:ba4edf3be8e97e4713d06c3d302cba1ff5c49d16e9d24c209884ac1b8455520c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4376d5acae0d1e91e78baeba4ee3cf22fbf6509d81539d01b94e0951d28ec2b6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f8fe6de652fcddae6dec8f281cc1e77e4e8f3575249e1800090aab48f73b4259" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:25ca2663d99328d51e5a138f22018e54c9162438d831e26cfc3458688616eca8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:12a6b2816b6cab6c3fd273d43b1948bc9acf708272074c8858f579c394f4cbc9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ac20dc3fcdfc7b8415bfc3d7d51beccd8695c3f4acb7f74e3a3b538e76672868" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:db0804d04564e70862ef807f3e1ace2cc212ef0e22deb1b3d6f80c45e5882c6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:979ce23ea663895ae39106946ef3d78527822d918a136dbc77b9e2b7f006237e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a2ba921b047bb029805726800819675249ef25d2f65fd0edb90639c5b1c3033c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:12d3d4dc33770069b780cc8f5abef909fe4a3f071f18f55f6d896a370fd0f970" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:aff032a59a201b3683a34be1169e71ddda683d9c3b43b261599c12055349251e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:30e590e133b06773f0dc9c3f82e567463df40598b660b5adf53eb1c488202544" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-win32.whl", hash = "sha256:8d7be7c99939cc58e7c5bcf6bb52a842a58e6c65e1e9cdd2a94b697b24cddb54" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp312-cp312-win_amd64.whl", hash = "sha256:2c0b4a67e75b945489052af6590e7dca0ed473ead5d0f3aad61fa584afe814ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:90d311ba8fcd733a3677e0be21804827226a57144130ba01c3c6a325e887dd86" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:feed6806f614bdf7f5cb6d0123cb0c1c5f40407ef103aa935cffaa694e2e0c74" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6b1d8d7c3e1a205c49e1aee6ba907dcb8ccea83651e6c3e2cb2062f1e52b0726" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:552f55745044a24c3cb7ec67e54234be56d5d6d0e054f2e4cf4fb3e297429be5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2da97ac65165d66b0570c9e545786f0ac7b5de5854d3711a16cacbcaa8c472d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f59a12966daa356bf68927fca5a67bebac0033cd18b96de9c2d426cd11756cd0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:133ae2098a8e162c71da97cdab1f383afdd91373b7ff5fe65169b04167da976b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7977640af7b7d5e6a852d26622057d428706a550f7f5083e7c4dd010a84d941f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b530ad6d55e71fa9e93e1109cf8182f427a6355848a4ffa09f69cc44e1512522" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:bd96a7d981bf64f0e42345584768da4435c05b24fd3c364663f5fbc8fabf82e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f28ee755fadb426ba2e464d6fcf25d3f152a05eb6b38e0b4f790352f5540c769" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-win32.whl", hash = "sha256:472785b52e48e3eed9b78b95e26a256f59bb1ee38339be3075dad799e2e1e661" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-cp313-cp313-win_amd64.whl", hash = "sha256:a1a85013eb33e4820286139540accbe2c98d2da894b2dcefd280209db508e608" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simplejson/simplejson-3.20.2-py3-none-any.whl", hash = "sha256:3b6bb7fb96efd673eac2e4235200bfffdc2353ad12c54117e1e4e2fc485ac017" }, +] + +[[package]] +name = "six" +version = "1.17.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/six/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/six/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274" }, +] + +[[package]] +name = "smmap" +version = "5.0.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/smmap/smmap-5.0.2.tar.gz", hash = "sha256:26ea65a03958fa0c8a1c7e8c7a58fdc77221b8910f6be2131affade476898ad5" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/smmap/smmap-5.0.2-py3-none-any.whl", hash = "sha256:b30115f0def7d7531d22a0fb6502488d879e75b260a9db4d0819cfb25403af5e" }, +] + +[[package]] +name = "snowballstemmer" +version = "3.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/snowballstemmer/snowballstemmer-3.0.1.tar.gz", hash = "sha256:6d5eeeec8e9f84d4d56b847692bacf79bc2c8e90c7f80ca4444ff8b6f2e52895" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/snowballstemmer/snowballstemmer-3.0.1-py3-none-any.whl", hash = "sha256:6cd7b3897da8d6c9ffb968a6781fa6532dce9c3618a4b127d920dab764a19064" }, +] + +[[package]] +name = "soupsieve" +version = "2.8.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/soupsieve/soupsieve-2.8.3.tar.gz", hash = "sha256:3267f1eeea4251fb42728b6dfb746edc9acaffc4a45b27e19450b676586e8349" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/soupsieve/soupsieve-2.8.3-py3-none-any.whl", hash = "sha256:ed64f2ba4eebeab06cc4962affce381647455978ffc1e36bb79a545b91f45a95" }, +] + +[[package]] +name = "sphinx" +version = "9.0.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +resolution-markers = [ + "python_full_version < '3.12' and sys_platform == 'win32'", + "python_full_version < '3.12' and sys_platform == 'emscripten'", + "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "alabaster", marker = "python_full_version < '3.12'" }, + { name = "babel", marker = "python_full_version < '3.12'" }, + { name = "colorama", marker = "python_full_version < '3.12' and sys_platform == 'win32'" }, + { name = "docutils", marker = "python_full_version < '3.12'" }, + { name = "imagesize", marker = "python_full_version < '3.12'" }, + { name = "jinja2", marker = "python_full_version < '3.12'" }, + { name = "packaging", marker = "python_full_version < '3.12'" }, + { name = "pygments", marker = "python_full_version < '3.12'" }, + { name = "requests", marker = "python_full_version < '3.12'" }, + { name = "roman-numerals", marker = "python_full_version < '3.12'" }, + { name = "snowballstemmer", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-applehelp", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-devhelp", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-htmlhelp", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-qthelp", marker = "python_full_version < '3.12'" }, + { name = "sphinxcontrib-serializinghtml", marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx/sphinx-9.0.4.tar.gz", hash = "sha256:594ef59d042972abbc581d8baa577404abe4e6c3b04ef61bd7fc2acbd51f3fa3" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx/sphinx-9.0.4-py3-none-any.whl", hash = "sha256:5bebc595a5e943ea248b99c13814c1c5e10b3ece718976824ffa7959ff95fffb" }, +] + +[[package]] +name = "sphinx" +version = "9.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "alabaster", marker = "python_full_version >= '3.12'" }, + { name = "babel", marker = "python_full_version >= '3.12'" }, + { name = "colorama", marker = "python_full_version >= '3.12' and sys_platform == 'win32'" }, + { name = "docutils", marker = "python_full_version >= '3.12'" }, + { name = "imagesize", marker = "python_full_version >= '3.12'" }, + { name = "jinja2", marker = "python_full_version >= '3.12'" }, + { name = "packaging", marker = "python_full_version >= '3.12'" }, + { name = "pygments", marker = "python_full_version >= '3.12'" }, + { name = "requests", marker = "python_full_version >= '3.12'" }, + { name = "roman-numerals", marker = "python_full_version >= '3.12'" }, + { name = "snowballstemmer", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-applehelp", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-devhelp", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-htmlhelp", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-jsmath", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-qthelp", marker = "python_full_version >= '3.12'" }, + { name = "sphinxcontrib-serializinghtml", marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx/sphinx-9.1.0.tar.gz", hash = "sha256:7741722357dd75f8190766926071fed3bdc211c74dd2d7d4df5404da95930ddb" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx/sphinx-9.1.0-py3-none-any.whl", hash = "sha256:c84fdd4e782504495fe4f2c0b3413d6c2bf388589bb352d439b2a3bb99991978" }, +] + +[[package]] +name = "sphinx-autodoc-typehints" +version = "3.6.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +resolution-markers = [ + "python_full_version < '3.12' and sys_platform == 'win32'", + "python_full_version < '3.12' and sys_platform == 'emscripten'", + "python_full_version < '3.12' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-autodoc-typehints/sphinx_autodoc_typehints-3.6.1.tar.gz", hash = "sha256:fa0b686ae1b85965116c88260e5e4b82faec3687c2e94d6a10f9b36c3743e2fe" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-autodoc-typehints/sphinx_autodoc_typehints-3.6.1-py3-none-any.whl", hash = "sha256:dd818ba31d4c97f219a8c0fcacef280424f84a3589cedcb73003ad99c7da41ca" }, +] + +[[package]] +name = "sphinx-autodoc-typehints" +version = "3.6.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +resolution-markers = [ + "python_full_version >= '3.14' and sys_platform == 'win32'", + "python_full_version >= '3.14' and sys_platform == 'emscripten'", + "python_full_version >= '3.14' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'win32'", + "python_full_version == '3.12.*' and sys_platform == 'win32'", + "python_full_version == '3.13.*' and sys_platform == 'emscripten'", + "python_full_version == '3.12.*' and sys_platform == 'emscripten'", + "python_full_version == '3.13.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", + "python_full_version == '3.12.*' and sys_platform != 'emscripten' and sys_platform != 'win32'", +] +dependencies = [ + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-autodoc-typehints/sphinx_autodoc_typehints-3.6.2.tar.gz", hash = "sha256:3d37709a21b7b765ad6e20a04ecefcb229b9eb0007cb24f6ebaa8a4576ea7f06" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-autodoc-typehints/sphinx_autodoc_typehints-3.6.2-py3-none-any.whl", hash = "sha256:9e70bee1f487b087c83ba0f4949604a4630bee396e263a324aae1dc4268d2c0f" }, +] + +[[package]] +name = "sphinx-book-theme" +version = "1.1.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "pydata-sphinx-theme" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-book-theme/sphinx_book_theme-1.1.4.tar.gz", hash = "sha256:73efe28af871d0a89bd05856d300e61edce0d5b2fbb7984e84454be0fedfe9ed" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-book-theme/sphinx_book_theme-1.1.4-py3-none-any.whl", hash = "sha256:843b3f5c8684640f4a2d01abd298beb66452d1b2394cd9ef5be5ebd5640ea0e1" }, +] + +[[package]] +name = "sphinx-collections" +version = "0.3.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "gitpython" }, + { name = "jinja2" }, + { name = "packaging" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-collections/sphinx_collections-0.3.1.tar.gz", hash = "sha256:4dda762479d2ad2163ccb074b15f36f72810d9cd08be4daa69854a6e34c99f92" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-collections/sphinx_collections-0.3.1-py3-none-any.whl", hash = "sha256:fb93b979cc9275bd2ad980a71fd57be5521c0f879f90f8189917a8f7ca0436ab" }, +] + +[[package]] +name = "sphinx-contributors" +version = "0.2.7" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-contributors/sphinx_contributors-0.2.7.tar.gz", hash = "sha256:aace731366096f2104a06eca77b9354b11768ddec149d699520c254f09cbb4f4" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-contributors/sphinx_contributors-0.2.7-py3-none-any.whl", hash = "sha256:f409295eb22f05606528ff3a9b93b4ae076d93d3153de13ff47bfcdd1c792463" }, +] + +[[package]] +name = "sphinx-gallery" +version = "0.20.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "pillow" }, + { name = "sphinx", version = "9.0.4", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version < '3.12'" }, + { name = "sphinx", version = "9.1.0", source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" }, marker = "python_full_version >= '3.12'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-gallery/sphinx_gallery-0.20.0.tar.gz", hash = "sha256:70281510c6183d812d3595957005ccf555c5a793f207410f6cd16a25bf08d735" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinx-gallery/sphinx_gallery-0.20.0-py3-none-any.whl", hash = "sha256:188b7456e269649945825661b76cdbfbf0b70c2cfd5b75c9a11fe52519879e4d" }, +] + +[[package]] +name = "sphinxcontrib-applehelp" +version = "2.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-applehelp/sphinxcontrib_applehelp-2.0.0.tar.gz", hash = "sha256:2f29ef331735ce958efa4734873f084941970894c6090408b079c61b2e1c06d1" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-applehelp/sphinxcontrib_applehelp-2.0.0-py3-none-any.whl", hash = "sha256:4cd3f0ec4ac5dd9c17ec65e9ab272c9b867ea77425228e68ecf08d6b28ddbdb5" }, +] + +[[package]] +name = "sphinxcontrib-devhelp" +version = "2.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-devhelp/sphinxcontrib_devhelp-2.0.0.tar.gz", hash = "sha256:411f5d96d445d1d73bb5d52133377b4248ec79db5c793ce7dbe59e074b4dd1ad" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-devhelp/sphinxcontrib_devhelp-2.0.0-py3-none-any.whl", hash = "sha256:aefb8b83854e4b0998877524d1029fd3e6879210422ee3780459e28a1f03a8a2" }, +] + +[[package]] +name = "sphinxcontrib-htmlhelp" +version = "2.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-htmlhelp/sphinxcontrib_htmlhelp-2.1.0.tar.gz", hash = "sha256:c9e2916ace8aad64cc13a0d233ee22317f2b9025b9cf3295249fa985cc7082e9" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-htmlhelp/sphinxcontrib_htmlhelp-2.1.0-py3-none-any.whl", hash = "sha256:166759820b47002d22914d64a075ce08f4c46818e17cfc9470a9786b759b19f8" }, +] + +[[package]] +name = "sphinxcontrib-jsmath" +version = "1.0.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-jsmath/sphinxcontrib-jsmath-1.0.1.tar.gz", hash = "sha256:a9925e4a4587247ed2191a22df5f6970656cb8ca2bd6284309578f2153e0c4b8" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-jsmath/sphinxcontrib_jsmath-1.0.1-py2.py3-none-any.whl", hash = "sha256:2ec2eaebfb78f3f2078e73666b1415417a116cc848b72e5172e596c871103178" }, +] + +[[package]] +name = "sphinxcontrib-qthelp" +version = "2.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-qthelp/sphinxcontrib_qthelp-2.0.0.tar.gz", hash = "sha256:4fe7d0ac8fc171045be623aba3e2a8f613f8682731f9153bb2e40ece16b9bbab" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-qthelp/sphinxcontrib_qthelp-2.0.0-py3-none-any.whl", hash = "sha256:b18a828cdba941ccd6ee8445dbe72ffa3ef8cbe7505d8cd1fa0d42d3f2d5f3eb" }, +] + +[[package]] +name = "sphinxcontrib-serializinghtml" +version = "2.0.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-serializinghtml/sphinxcontrib_serializinghtml-2.0.0.tar.gz", hash = "sha256:e9d912827f872c029017a53f0ef2180b327c3f7fd23c87229f7a8e8b70031d4d" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sphinxcontrib-serializinghtml/sphinxcontrib_serializinghtml-2.0.0-py3-none-any.whl", hash = "sha256:6e2cb0eef194e10c27ec0023bfeb25badbbb5868244cf5bc5bdc04e4464bf331" }, +] + +[[package]] +name = "sqlalchemy" +version = "2.0.46" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "greenlet", marker = "platform_machine == 'AMD64' or platform_machine == 'WIN32' or platform_machine == 'aarch64' or platform_machine == 'amd64' or platform_machine == 'ppc64le' or platform_machine == 'win32' or platform_machine == 'x86_64'" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46.tar.gz", hash = "sha256:cf36851ee7219c170bb0793dbc3da3e80c582e04a5437bc601bfe8c85c9216d7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:261c4b1f101b4a411154f1da2b76497d73abbfc42740029205d4d01fa1052684" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:181903fe8c1b9082995325f1b2e84ac078b1189e2819380c2303a5f90e114a62" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:590be24e20e2424a4c3c1b0835e9405fa3d0af5823a1a9fc02e5dff56471515f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7568fe771f974abadce52669ef3a03150ff03186d8eb82613bc8adc435a03f01" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ebf7e1e78af38047e08836d33502c7a278915698b7c2145d045f780201679999" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-win32.whl", hash = "sha256:9d80ea2ac519c364a7286e8d765d6cd08648f5b21ca855a8017d9871f075542d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp311-cp311-win_amd64.whl", hash = "sha256:585af6afe518732d9ccd3aea33af2edaae4a7aa881af5d8f6f4fe3a368699597" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3a9a72b0da8387f15d5810f1facca8f879de9b85af8c645138cba61ea147968c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2347c3f0efc4de367ba00218e0ae5c4ba2306e47216ef80d6e31761ac97cb0b9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9094c8b3197db12aa6f05c51c05daaad0a92b8c9af5388569847b03b1007fb1b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:37fee2164cf21417478b6a906adc1a91d69ae9aba8f9533e67ce882f4bb1de53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b1e14b2f6965a685c7128bd315e27387205429c2e339eeec55cb75ca4ab0ea2e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-win32.whl", hash = "sha256:412f26bb4ba942d52016edc8d12fb15d91d3cd46b0047ba46e424213ad407bcb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp312-cp312-win_amd64.whl", hash = "sha256:ea3cd46b6713a10216323cda3333514944e510aa691c945334713fca6b5279ff" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:93a12da97cca70cea10d4b4fc602589c4511f96c1f8f6c11817620c021d21d00" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:af865c18752d416798dae13f83f38927c52f085c52e2f32b8ab0fef46fdd02c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8d679b5f318423eacb61f933a9a0f75535bfca7056daeadbf6bd5bcee6183aee" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:64901e08c33462acc9ec3bad27fc7a5c2b6491665f2aa57564e57a4f5d7c52ad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e8ac45e8f4eaac0f9f8043ea0e224158855c6a4329fd4ee37c45c61e3beb518e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-win32.whl", hash = "sha256:8d3b44b3d0ab2f1319d71d9863d76eeb46766f8cf9e921ac293511804d39813f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313-win_amd64.whl", hash = "sha256:77f8071d8fbcbb2dd11b7fd40dedd04e8ebe2eb80497916efedba844298065ef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a1e8cc6cc01da346dc92d9509a63033b9b1bda4fed7a7a7807ed385c7dccdc10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:96c7cca1a4babaaf3bfff3e4e606e38578856917e52f0384635a95b226c87764" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b2a9f9aee38039cf4755891a1e50e1effcc42ea6ba053743f452c372c3152b1b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:db23b1bf8cfe1f7fda19018e7207b20cdb5168f83c437ff7e95d19e39289c447" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:56bdd261bfd0895452006d5316cbf35739c53b9bb71a170a331fa0ea560b2ada" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:33e462154edb9493f6c3ad2125931e273bbd0be8ae53f3ecd1c161ea9a1dd366" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9bcdce05f056622a632f1d44bb47dbdb677f58cad393612280406ce37530eb6d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:8e84b09a9b0f19accedcbeff5c2caf36e0dd537341a33aad8d680336152dc34e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4f52f7291a92381e9b4de9050b0a65ce5d6a763333406861e33906b8aa4906bf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-win32.whl", hash = "sha256:70ed2830b169a9960193f4d4322d22be5c0925357d82cbf485b3369893350908" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314-win_amd64.whl", hash = "sha256:3c32e993bc57be6d177f7d5d31edb93f30726d798ad86ff9066d75d9bf2e0b6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4dafb537740eef640c4d6a7c254611dca2df87eaf6d14d6a5fca9d1f4c3fc0fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42a1643dc5427b69aca967dae540a90b0fbf57eaf248f13a90ea5930e0966863" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ff33c6e6ad006bbc0f34f5faf941cfc62c45841c64c0a058ac38c799f15b5ede" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:82ec52100ec1e6ec671563bbd02d7c7c8d0b9e71a0723c72f22ecf52d1755330" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sqlalchemy/sqlalchemy-2.0.46-py3-none-any.whl", hash = "sha256:f9c11766e7e7c0a2767dda5acb006a118640c9fc0a4104214b96269bfb78399e" }, +] + +[[package]] +name = "stack-data" +version = "0.6.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/stack-data/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/stack-data/stack_data-0.6.3-py3-none-any.whl", hash = "sha256:d5558e0c25a4cb0853cddad3d77da9891a08cb85dd9f9f91b9f8cd66e511e695" }, +] + +[[package]] +name = "sympy" +version = "1.14.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "mpmath" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sympy/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/sympy/sympy-1.14.0-py3-none-any.whl", hash = "sha256:e091cc3e99d2141a0ba2847328f5479b05d94a6635cb96148ccb3f34671bd8f5" }, +] + +[[package]] +name = "tabulate" +version = "0.9.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tabulate/tabulate-0.9.0.tar.gz", hash = "sha256:0095b12bf5966de529c0feb1fa08671671b3368eec77d7ef7ab114be2c068b3c" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tabulate/tabulate-0.9.0-py3-none-any.whl", hash = "sha256:024ca478df22e9340661486f85298cff5f6dcdba14f3813e8830015b9ed1948f" }, +] + +[[package]] +name = "tenacity" +version = "9.1.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tenacity/tenacity-9.1.4.tar.gz", hash = "sha256:adb31d4c263f2bd041081ab33b498309a57c77f9acf2db65aadf0898179cf93a" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tenacity/tenacity-9.1.4-py3-none-any.whl", hash = "sha256:6095a360c919085f28c6527de529e76a06ad89b23659fa881ae0649b867a9d55" }, +] + +[[package]] +name = "tensorboardx" +version = "2.6.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorboardx/tensorboardx-2.6.4.tar.gz", hash = "sha256:b163ccb7798b31100b9f5fa4d6bc22dad362d7065c2f24b51e50731adde86828" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorboardx/tensorboardx-2.6.4-py3-none-any.whl", hash = "sha256:5970cf3a1f0a6a6e8b180ccf46f3fe832b8a25a70b86e5a237048a7c0beb18e2" }, +] + +[[package]] +name = "tensorflow-datasets" +version = "4.9.9" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "array-record", marker = "sys_platform == 'linux'" }, + { name = "dm-tree" }, + { name = "etils", extra = ["edc", "enp", "epath", "epy", "etree"] }, + { name = "immutabledict" }, + { name = "numpy" }, + { name = "promise" }, + { name = "protobuf" }, + { name = "psutil" }, + { name = "pyarrow" }, + { name = "requests" }, + { name = "simple-parsing" }, + { name = "tensorflow-metadata" }, + { name = "termcolor" }, + { name = "toml" }, + { name = "tqdm" }, + { name = "wrapt" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorflow-datasets/tensorflow_datasets-4.9.9.tar.gz", hash = "sha256:9cb245cad97e7d227f0b8e006491cfef860ff8d4b9d84a3c68f8b96d6295355e" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorflow-datasets/tensorflow_datasets-4.9.9-py3-none-any.whl", hash = "sha256:b94902d414cdc12a1014cda9ee5815c502c3d44215b780e06dacbd7949abd14e" }, +] + +[[package]] +name = "tensorflow-metadata" +version = "1.17.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "absl-py" }, + { name = "googleapis-common-protos" }, + { name = "protobuf" }, +] +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorflow-metadata/tensorflow_metadata-1.17.3-py3-none-any.whl", hash = "sha256:452912e6398b3cb7302f0de6139dea794b3be1bd0eb40e6765eb3a04e51ea991" }, +] + +[[package]] +name = "tensorstore" +version = "0.1.81" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "ml-dtypes" }, + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81.tar.gz", hash = "sha256:687546192ea6f6c8ae28d18f13103336f68017d928b9f5a00325e9b0548d9c25" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:f64fb510f293079f9e5c63cb227e8a76904655a32912fc107c1e63bd8dc3e187" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4282587598885ff447f08369ac9bb681a65e224888cfa8ef8f3dd63544759e6c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9b4ea06038f6912bb6ed8a89db0c31e4e3d1b2404f3365dc756e4bc42bd6a89c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:51d59f7db9cdae02fce9d347300c0ccfb8265052945757e95592a265eb620b15" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp311-cp311-win_amd64.whl", hash = "sha256:fdb9579a729cccc02127cab5abf26f57a0e27968ba65c9c548ad058f5a45417f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:7aefa1e3eadca804bce05215184c9cde29205ac2f3b443ca15a4e1846d31af4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7e001d3edc6758eb5dc80556da9e945c1381f0529102fcc0301358ba6b9b70ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c27e07f4e91e6dc6a0878e13e2c5931d1716196b67b0df927f2f571de2576e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fcb4786c4955e2d88d518b5b5a367427e3ad21d059cba366ad7aebf5fcc2302e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp312-cp312-win_amd64.whl", hash = "sha256:b96cbf1ee74d9038762b2d81305ee1589ec89913a440df6cbd514bc5879655d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp313-cp313-macosx_10_14_x86_64.whl", hash = "sha256:7bb563ad4d4d6c4748d9fe4f01f639ddf4ffef83ac180fc3b6d73f46ad854e62" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2ff7e6c457596cf21f31c690e451fe634ac804fc98ff8131188e99d5ef7d29bc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b218a6fe09c72c002f2c6480fc58b78cdbba8bb9c6f3a0d7dd1f70625cb37995" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f33e7c11035c14dad01aeba012051643110cbb95c239e512106fe1be692c98b6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp313-cp313-win_amd64.whl", hash = "sha256:b55126bcf084cc5fe0151bf465f3a5dedb5b5da0133d01227f75d0e71f9cfae5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:a48c23e4df50681d8f4f365b08a0beb114ab210accbde9f34d37fd7b45c31005" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:0be0ce646263820f3d4c9ba738d8e9be7da241cbe093ca2fd02e25023344347c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93996e756dce82589f5a19e27b4e7c0b5b40221a7e41ddce46dc13d378dbd157" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:444c088919a739c20ca1f87935d72de4fd87605eb2c0f093b8d49251b7884aef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314-win_amd64.whl", hash = "sha256:f7aa0a3a470c4d832faff7d77dd688b1d352b718d110c95ceba54ec637ca3ffa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:6c36d8a827120aa15e50ec5c36dd7e73978d86ba4f46d073fb648d8dda3948e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:3c31d831707c4ff3c6ecdcba129f7c39e982572837b2f93e02ccb83fc8581bca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:9fba383f108d7450bf9a03487ac7fa3bb2c3080c91cee9d2da3bb217b560846b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tensorstore/tensorstore-0.1.81-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:f88c52f592e2982682045199cabf360462146749d48b7be2969cd640e877c6c3" }, +] + +[[package]] +name = "termcolor" +version = "3.3.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/termcolor/termcolor-3.3.0.tar.gz", hash = "sha256:348871ca648ec6a9a983a13ab626c0acce02f515b9e1983332b17af7979521c5" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/termcolor/termcolor-3.3.0-py3-none-any.whl", hash = "sha256:cf642efadaf0a8ebbbf4bc7a31cec2f9b5f21a9f726f4ccbb08192c9c26f43a5" }, +] + +[[package]] +name = "tokenizers" +version = "0.22.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "huggingface-hub" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tokenizers/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc" }, +] + +[[package]] +name = "toml" +version = "0.10.2" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/toml/toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/toml/toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b" }, +] + +[[package]] +name = "toolz" +version = "1.1.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/toolz/toolz-1.1.0.tar.gz", hash = "sha256:27a5c770d068c110d9ed9323f24f1543e83b2f300a687b7891c1a6d56b697b5b" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/toolz/toolz-1.1.0-py3-none-any.whl", hash = "sha256:15ccc861ac51c53696de0a5d6d4607f99c210739caf987b5d2054f3efed429d8" }, +] + +[[package]] +name = "tornado" +version = "6.5.4" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4.tar.gz", hash = "sha256:a22fa9047405d03260b483980635f0b041989d8bcc9a313f8fe18b411d84b1d7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:d6241c1a16b1c9e4cc28148b1cda97dd1c6cb4fb7068ac1bedc610768dff0ba9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-macosx_10_9_x86_64.whl", hash = "sha256:2d50f63dda1d2cac3ae1fa23d254e16b5e38153758470e9956cbc3d813d40843" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cf66105dc6acb5af613c054955b8137e34a03698aa53272dbda4afe252be17" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:50ff0a58b0dc97939d29da29cd624da010e7f804746621c78d14b80238669335" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5fb5e04efa54cf0baabdd10061eb4148e0be137166146fff835745f59ab9f7f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:9c86b1643b33a4cd415f8d0fe53045f913bf07b4a3ef646b735a6a86047dda84" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:6eb82872335a53dd063a4f10917b3efd28270b56a33db69009606a0312660a6f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:6076d5dda368c9328ff41ab5d9dd3608e695e8225d1cd0fd1e006f05da3635a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-win32.whl", hash = "sha256:1768110f2411d5cd281bac0a090f707223ce77fd110424361092859e089b38d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-win_amd64.whl", hash = "sha256:fa07d31e0cd85c60713f2b995da613588aa03e1303d75705dca6af8babc18ddc" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tornado/tornado-6.5.4-cp39-abi3-win_arm64.whl", hash = "sha256:053e6e16701eb6cbe641f308f4c1a9541f91b6261991160391bfc342e8a551a1" }, +] + +[[package]] +name = "tqdm" +version = "4.67.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "colorama", marker = "sys_platform == 'win32'" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tqdm/tqdm-4.67.3.tar.gz", hash = "sha256:7d825f03f89244ef73f1d4ce193cb1774a8179fd96f31d7e1dcde62092b960bb" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tqdm/tqdm-4.67.3-py3-none-any.whl", hash = "sha256:ee1e4c0e59148062281c49d80b25b67771a127c85fc9676d3be5f243206826bf" }, +] + +[[package]] +name = "traitlets" +version = "5.14.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/traitlets/traitlets-5.14.3.tar.gz", hash = "sha256:9ed0579d3502c94b4b3732ac120375cda96f923114522847de4b3bb98b96b6b7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/traitlets/traitlets-5.14.3-py3-none-any.whl", hash = "sha256:b74e89e397b1ed28cc831db7aea759ba6640cb3de13090ca145426688ff1ac4f" }, +] + +[[package]] +name = "transformers" +version = "4.57.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "filelock" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/transformers/transformers-4.57.1.tar.gz", hash = "sha256:f06c837959196c75039809636cd964b959f6604b75b8eeec6fdfc0440b89cc55" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/transformers/transformers-4.57.1-py3-none-any.whl", hash = "sha256:b10d05da8fa67dc41644dbbf9bc45a44cb86ae33da6f9295f5fbf5b7890bd267" }, +] + +[[package]] +name = "treescope" +version = "0.1.10" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "numpy" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/treescope/treescope-0.1.10.tar.gz", hash = "sha256:20f74656f34ab2d8716715013e8163a0da79bdc2554c16d5023172c50d27ea95" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/treescope/treescope-0.1.10-py3-none-any.whl", hash = "sha256:dde52f5314f4c29d22157a6fe4d3bd103f9cae02791c9e672eefa32c9aa1da51" }, +] + +[[package]] +name = "typing-extensions" +version = "4.15.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/typing-extensions/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/typing-extensions/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548" }, +] + +[[package]] +name = "typing-inspect" +version = "0.9.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "mypy-extensions" }, + { name = "typing-extensions" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/typing-inspect/typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/typing-inspect/typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f" }, +] + +[[package]] +name = "tzdata" +version = "2025.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tzdata/tzdata-2025.3.tar.gz", hash = "sha256:de39c2ca5dc7b0344f2eba86f49d614019d29f060fc4ebc8a417896a620b56a7" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/tzdata/tzdata-2025.3-py2.py3-none-any.whl", hash = "sha256:06a47e5700f3081aab02b2e513160914ff0694bce9947d6b76ebd6bf57cfc5d1" }, +] + +[[package]] +name = "urllib3" +version = "2.6.3" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/urllib3/urllib3-2.6.3.tar.gz", hash = "sha256:1b62b6884944a57dbe321509ab94fd4d3b307075e0c2eae991ac71ee15ad38ed" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/urllib3/urllib3-2.6.3-py3-none-any.whl", hash = "sha256:bf272323e553dfb2e87d9bfd225ca7b0f467b919d7bbd355436d3fd37cb0acd4" }, +] + +[[package]] +name = "wadler-lindig" +version = "0.1.7" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wadler-lindig/wadler_lindig-0.1.7.tar.gz", hash = "sha256:81d14d3fe77d441acf3ebd7f4aefac20c74128bf460e84b512806dccf7b2cd55" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wadler-lindig/wadler_lindig-0.1.7-py3-none-any.whl", hash = "sha256:e3ec83835570fd0a9509f969162aeb9c65618f998b1f42918cfc8d45122fe953" }, +] + +[[package]] +name = "wcwidth" +version = "0.6.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wcwidth/wcwidth-0.6.0.tar.gz", hash = "sha256:cdc4e4262d6ef9a1a57e018384cbeb1208d8abbc64176027e2c2455c81313159" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wcwidth/wcwidth-0.6.0-py3-none-any.whl", hash = "sha256:1a3a1e510b553315f8e146c54764f4fb6264ffad731b3d78088cdb1478ffbdad" }, +] + +[[package]] +name = "wrapt" +version = "2.1.1" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1.tar.gz", hash = "sha256:5fdcb09bf6db023d88f312bd0767594b414655d58090fc1c46b3414415f67fac" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6c366434a7fb914c7a5de508ed735ef9c133367114e1a7cb91dfb5cd806a1549" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5d6a2068bd2e1e19e5a317c8c0b288267eec4e7347c36bc68a6e378a39f19ee7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:891ab4713419217b2aed7dd106c9200f64e6a82226775a0d2ebd6bef2ebd1747" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c8ef36a0df38d2dc9d907f6617f89e113c5892e0a35f58f45f75901af0ce7d81" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76e9af3ebd86f19973143d4d592cbf3e970cf3f66ddee30b16278c26ae34b8ab" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ff562067485ebdeaef2fa3fe9b1876bc4e7b73762e0a01406ad81e2076edcebf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-win32.whl", hash = "sha256:9e60a30aa0909435ec4ea2a3c53e8e1b50ac9f640c0e9fe3f21fd248a22f06c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:7d79954f51fcf84e5ec4878ab4aea32610d70145c5bbc84b3370eabfb1e096c2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:d3ffc6b0efe79e08fd947605fd598515aebefe45e50432dc3b5cd437df8b1ada" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab8e3793b239db021a18782a5823fcdea63b9fe75d0e340957f5828ef55fcc02" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7c0300007836373d1c2df105b40777986accb738053a92fe09b615a7a4547e9f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:2b27c070fd1132ab23957bcd4ee3ba707a91e653a9268dc1afbd39b77b2799f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b0e36d845e8b6f50949b6b65fc6cd279f47a1944582ed4ec8258cd136d89a64" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4aeea04a9889370fcfb1ef828c4cc583f36a875061505cd6cd9ba24d8b43cc36" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:d88b46bb0dce9f74b6817bc1758ff2125e1ca9e1377d62ea35b6896142ab6825" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-win32.whl", hash = "sha256:63decff76ca685b5c557082dfbea865f3f5f6d45766a89bff8dc61d336348833" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:b828235d26c1e35aca4107039802ae4b1411be0fe0367dd5b7e4d90e562fcbcd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:75128507413a9f1bcbe2db88fd18fbdbf80f264b82fa33a6996cdeaf01c52352" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ce9646e17fa7c3e2e7a87e696c7de66512c2b4f789a8db95c613588985a2e139" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:428cfc801925454395aa468ba7ddb3ed63dc0d881df7b81626cdd433b4e2b11b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:5797f65e4d58065a49088c3b32af5410751cd485e83ba89e5a45e2aa8905af98" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a2db44a71202c5ae4bb5f27c6d3afbc5b23053f2e7e78aa29704541b5dad789" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:8d5350c3590af09c1703dd60ec78a7370c0186e11eaafb9dda025a30eee6492d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:2d9b076411bed964e752c01b49fd224cc385f3a96f520c797d38412d70d08359" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-win32.whl", hash = "sha256:0bb7207130ce6486727baa85373503bf3334cc28016f6928a0fa7e19d7ecdc06" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:cbfee35c711046b15147b0ae7db9b976f01c9520e6636d992cd9e69e5e2b03b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:7d2756061022aebbf57ba14af9c16e8044e055c22d38de7bf40d92b565ecd2b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4814a3e58bc6971e46baa910ecee69699110a2bf06c201e24277c65115a20c20" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:106c5123232ab9b9f4903692e1fa0bdc231510098f04c13c3081f8ad71c3d612" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:1a40b83ff2535e6e56f190aff123821eea89a24c589f7af33413b9c19eb2c738" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:789cea26e740d71cf1882e3a42bb29052bc4ada15770c90072cb47bf73fb3dbf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:ba49c14222d5e5c0ee394495a8655e991dc06cbca5398153aefa5ac08cd6ccd7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ac8cda531fe55be838a17c62c806824472bb962b3afa47ecbd59b27b78496f4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-win32.whl", hash = "sha256:b8af75fe20d381dd5bcc9db2e86a86d7fcfbf615383a7147b85da97c1182225b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:45c5631c9b6c792b78be2d7352129f776dd72c605be2c3a4e9be346be8376d83" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:da815b9263947ac98d088b6414ac83507809a1d385e4632d9489867228d6d81c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:9aa1765054245bb01a37f615503290d4e207e3fd59226e78341afb587e9c1236" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:feff14b63a6d86c1eee33a57f77573649f2550935981625be7ff3cb7342efe05" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:81fc5f22d5fcfdbabde96bb3f5379b9f4476d05c6d524d7259dc5dfb501d3281" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:951b228ecf66def855d22e006ab9a1fc12535111ae7db2ec576c728f8ddb39e8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:0ddf582a95641b9a8c8bd643e83f34ecbbfe1b68bc3850093605e469ab680ae3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:fc5c500966bf48913f795f1984704e6d452ba2414207b15e1f8c339a059d5b16" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-win32.whl", hash = "sha256:4aa4baadb1f94b71151b8e44a0c044f6af37396c3b8bcd474b78b49e2130a23b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:860e9d3fd81816a9f4e40812f28be4439ab01f260603c749d14be3c0a1170d19" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:3c59e103017a2c1ea0ddf589cbefd63f91081d7ce9d491d69ff2512bb1157e23" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:9fa7c7e1bee9278fc4f5dd8275bc8d25493281a8ec6c61959e37cc46acf02007" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:39c35e12e8215628984248bd9c8897ce0a474be2a773db207eb93414219d8469" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:94ded4540cac9125eaa8ddf5f651a7ec0da6f5b9f248fe0347b597098f8ec14c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:da0af328373f97ed9bdfea24549ac1b944096a5a71b30e41c9b8b53ab3eec04a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:4ad839b55f0bf235f8e337ce060572d7a06592592f600f3a3029168e838469d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:0d89c49356e5e2a50fa86b40e0510082abcd0530f926cbd71cf25bee6b9d82d7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-win32.whl", hash = "sha256:f4c7dd22cf7f36aafe772f3d88656559205c3af1b7900adfccb70edeb0d2abc4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f76bc12c583ab01e73ba0ea585465a41e48d968f6d1311b4daec4f8654e356e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7ea74fc0bec172f1ae5f3505b6655c541786a5cabe4bbc0d9723a56ac32eb9b9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/wrapt/wrapt-2.1.1-py3-none-any.whl", hash = "sha256:3b0f4629eb954394a3d7c7a1c8cca25f0b07cefe6aa8545e862e9778152de5b7" }, +] + +[[package]] +name = "xxhash" +version = "3.6.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/xxhash/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d" }, +] + +[[package]] +name = "yarl" +version = "1.22.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +dependencies = [ + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, +] +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:1ab72135b1f2db3fed3997d7e7dc1b80573c67138023852b6efb336a5eae6511" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:669930400e375570189492dc8d8341301578e8493aec04aebc20d4717f899dd6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:792a2af6d58177ef7c19cbf0097aba92ca1b9cb3ffdd9c7470e156c8f9b5e028" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3ea66b1c11c9150f1372f69afb6b8116f2dd7286f38e14ea71a44eee9ec51b9d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3e2daa88dc91870215961e96a039ec73e4937da13cf77ce17f9cad0c18df3503" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba440ae430c00eee41509353628600212112cd5018d5def7e9b05ea7ac34eb65" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:e6438cc8f23a9c1478633d216b16104a586b9761db62bfacb6425bac0a36679e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c52a6e78aef5cf47a98ef8e934755abf53953379b7d53e68b15ff4420e6683d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3b06bcadaac49c70f4c88af4ffcfbe3dc155aab3163e75777818092478bcbbe7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:6944b2dc72c4d7f7052683487e3677456050ff77fcf5e6204e98caf785ad1967" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:d5372ca1df0f91a86b047d1277c2aaf1edb32d78bbcefffc81b40ffd18f027ed" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:51af598701f5299012b8416486b40fceef8c26fc87dc6d7d1f6fc30609ea0aa6" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b266bd01fedeffeeac01a79ae181719ff848a5a13ce10075adbefc8f1daee70e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-win32.whl", hash = "sha256:a9b1ba5610a4e20f655258d5a1fdc7ebe3d837bb0e45b581398b99eb98b1f5ca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-win_amd64.whl", hash = "sha256:078278b9b0b11568937d9509b589ee83ef98ed6d561dfe2020e24a9fd08eaa2b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp311-cp311-win_arm64.whl", hash = "sha256:b6a6f620cfe13ccec221fa312139135166e47ae169f8253f72a0abc0dae94376" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1" }, + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/yarl/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff" }, +] + +[[package]] +name = "zipp" +version = "3.23.0" +source = { registry = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/simple/" } +sdist = { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/zipp/zipp-3.23.0.tar.gz", hash = "sha256:a07157588a12518c9d4034df3fbbee09c814741a33ff63c05fa29d26a2404166" } +wheels = [ + { url = "https://us-python.pkg.dev/artifact-foundry-prod/ah-3p-staging-python/zipp/zipp-3.23.0-py3-none-any.whl", hash = "sha256:071652d6115ed432f5ce1d34c336c0adfd6a884660d1e9712a256d3d3bd4b14e" }, +]