diff --git a/deps/renderers b/deps/renderers index d4707862ac..66505d2806 160000 --- a/deps/renderers +++ b/deps/renderers @@ -1 +1 @@ -Subproject commit d4707862ac83aa3773c21f4096aec72bd17b91e4 +Subproject commit 66505d280683654a98d97a5eb7d627f41650c923 diff --git a/deps/verifiers b/deps/verifiers index f646beb37e..88c759b0f6 160000 --- a/deps/verifiers +++ b/deps/verifiers @@ -1 +1 @@ -Subproject commit f646beb37eef51869f886f244456e3d07818e4d6 +Subproject commit 88c759b0f68a1018b9c5015e4640979184b34cf9 diff --git a/docs/advanced.md b/docs/advanced.md index c4c1ba9b9c..e9d6e5f41f 100644 --- a/docs/advanced.md +++ b/docs/advanced.md @@ -98,7 +98,8 @@ VLM training requires a registered custom PrimeRL implementation. ### Limitations -- **Vision encoder frozen by default.** The default LoRA targets do not match Qwen3.5 vision modules. Set `freeze_vision_encoder = false` to fine-tune the encoder; this is incompatible with LoRA because LoRA freezes all non-adapter parameters. +- **Vision encoder frozen by default.** The default LoRA targets do not match Qwen3.5 vision modules. Set `freeze_vision_encoder = false` to fine-tune it; in that case it's FSDP-sharded per block. The combination `freeze_vision_encoder = false` + LoRA is rejected by a config validator — LoRA freezes everything non-adapter, so unfreezing the encoder under LoRA would be a silent no-op. +- **Truncation cuts at image boundaries.** Raw multimodal samples that exceed `seq_len` are truncated before packing at the start of the first image that doesn't fit — an image placeholder span is never split, and refs for dropped images are discarded. A sample whose leading image alone exceeds `seq_len` is rejected. - **bfloat16 mandatory.** The trainer config validator refuses any other `optimization_dtype` / `reduce_dtype` for VLMs — vLLM serves VLMs in bfloat16 and a mismatch breaks the importance ratio. - **Higher KL mismatch with multi-image inputs.** Expect noisier `mismatch_kl` than text-only; this is from minor numerical differences between the trainer's and vLLM's image processing. - **Images aren't logged to monitors.** Sample logging captures the prompt text but not the actual images. diff --git a/docs/configuration.md b/docs/configuration.md index fbfdc5b67c..7f51824665 100644 --- a/docs/configuration.md +++ b/docs/configuration.md @@ -226,7 +226,7 @@ The `rl` launcher applies these the same way in both single-node and multi-node 1. The launcher's own defaults — **your `env_vars` override these**. 2. Your top-level `[env_vars]`. 3. Your `[component.env_vars]`. -4. Orchestration-critical vars the launcher always sets last — `CUDA_VISIBLE_DEVICES` (GPU partitioning) and `WANDB_SHARED_*` (the single shared W&B run) — **these cannot be overridden** from `env_vars`. +4. Orchestration-critical vars the launcher always sets last — `CUDA_VISIBLE_DEVICES` (GPU partitioning), `WANDB_SHARED_*` (the single shared W&B run), and `VF_RENDERER_IMAGE_OFFLOAD_DIR` (raw multimodal image asset path) — **these cannot be overridden** from `env_vars`. For standalone `sft` and `inference` configs, `[env_vars]` applies to that entrypoint's process(es). For disaggregated P/D inference, the role-specific [`deployment.{prefill,decode}_env_vars`](inference.md) layer on top of any shared inference env vars. diff --git a/packages/prime-rl-configs/src/prime_rl/configs/inference.py b/packages/prime-rl-configs/src/prime_rl/configs/inference.py index baab060f95..e9924c711d 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/inference.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/inference.py @@ -5,7 +5,7 @@ from pydantic import Field, model_validator from pydantic_config import BaseConfig -from prime_rl.configs.shared import BaseModelConfig, EnvVars, LogConfig, SlurmConfig +from prime_rl.configs.shared import BaseModelConfig, EnvVars, LogConfig, MultimodalConfig, SlurmConfig from prime_rl.utils.config import find_package_resource, rgetattr, rsetattr from prime_rl.utils.parsers import resolve_reasoning_parser, resolve_tool_call_parser @@ -423,6 +423,9 @@ class InferenceConfig(BaseConfig): dry_run: bool = False """Only validate and dump resolved configs, then exit early.""" + multimodal: MultimodalConfig = MultimodalConfig() + """Raw multimodal image offload settings shared with trainer and orchestrator.""" + @model_validator(mode="after") def validate_multi_node_requires_slurm(self): if self.deployment.type in ("multi_node", "disaggregated") and self.slurm is None: diff --git a/packages/prime-rl-configs/src/prime_rl/configs/orchestrator.py b/packages/prime-rl-configs/src/prime_rl/configs/orchestrator.py index 434a361f28..2c1b3fd1bd 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/orchestrator.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/orchestrator.py @@ -16,6 +16,7 @@ FileMonitorConfig, HeartbeatConfig, LogConfig, + MultimodalConfig, PrimeMonitorConfig, TransportConfig, WandbWithExtrasConfig, @@ -563,6 +564,9 @@ class OrchestratorConfig(BaseConfig): heartbeat: HeartbeatConfig | None = None """BetterStack heartbeat configuration for monitoring training progress.""" + multimodal: MultimodalConfig = MultimodalConfig() + """Raw multimodal image offload settings shared with trainer and inference.""" + @model_validator(mode="after") def auto_setup_tokenizer(self): if self.tokenizer.name is None: diff --git a/packages/prime-rl-configs/src/prime_rl/configs/rl.py b/packages/prime-rl-configs/src/prime_rl/configs/rl.py index 8a4a02ae21..a889be4581 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/rl.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/rl.py @@ -21,6 +21,7 @@ from prime_rl.configs.shared import ( EnvVars, FileMonitorConfig, + MultimodalConfig, SlurmConfig, TransportConfig, VLMConfig, @@ -261,6 +262,8 @@ class RLConfig(BaseConfig): weight_broadcast: SharedWeightBroadcastConfig | None = None + multimodal: MultimodalConfig = MultimodalConfig() + """Shared raw multimodal image offload settings. Propagated to trainer, orchestrator, and inference.""" rollout_transport: TransportConfig | None = None bench: bool = False diff --git a/packages/prime-rl-configs/src/prime_rl/configs/sft.py b/packages/prime-rl-configs/src/prime_rl/configs/sft.py index 941c531deb..8308b7130e 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/sft.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/sft.py @@ -248,6 +248,23 @@ def normalize_deployment(cls, data): ### Validate configs (e.g. raise for unsupported (combinations of) configs) + @model_validator(mode="after") + def renderer_emits_processed_multimodal(self): + """SFT consumes processed pixel tensors straight from the renderer — it has no + raw-ref materializer, so the renderers-library default of ``multimodal_output='raw'`` + (built for the RL offload path) would silently ship JSON descriptors into training. + Default SFT renderers to ``'processed'`` and reject an explicit ``'raw'``.""" + if "multimodal_output" in self.renderer.model_fields_set: + if self.renderer.multimodal_output == "raw": + raise ValueError( + "multimodal_output='raw' is unsupported for SFT: the SFT data path materializes " + "images from processed renderer output, not raw refs. Remove the override " + "(SFT defaults to 'processed')." + ) + else: + self.renderer = self.renderer.model_copy(update={"multimodal_output": "processed"}) + return self + @model_validator(mode="after") def deepep_disables_grad_clipping(self): if self.model.ep_comm_backend == "deepep" and self.optim.max_norm is not None: diff --git a/packages/prime-rl-configs/src/prime_rl/configs/shared.py b/packages/prime-rl-configs/src/prime_rl/configs/shared.py index 74f2a859b8..a8ce6f22f1 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/shared.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/shared.py @@ -10,7 +10,13 @@ # and the single shared W&B run. The launcher always sets these last, so allowing them in # `env_vars` would be a silent no-op (or, on multi-node, a footgun) — reject them instead. PROTECTED_ENV_VARS = frozenset( - {"CUDA_VISIBLE_DEVICES", "WANDB_SHARED_MODE", "WANDB_SHARED_RUN_ID", "WANDB_SHARED_LABEL"} + { + "CUDA_VISIBLE_DEVICES", + "VF_RENDERER_IMAGE_OFFLOAD_DIR", + "WANDB_SHARED_MODE", + "WANDB_SHARED_RUN_ID", + "WANDB_SHARED_LABEL", + } ) @@ -86,6 +92,11 @@ def resolve_project_dir(self): ServerType = Literal["vllm", "openai"] +class MultimodalConfig(BaseConfig): + offload_dir: Path | None = None + """Directory for offloaded image assets. Supports environment expansion such as ``/data/outputs/run_${RUN_ID}/assets/images``. When unset, prime-rl resolves a run-scoped default.""" + + class VLMConfig(BaseConfig): vision_encoder_attr: str """Dotted attribute path to the vision encoder module (e.g. ``model.visual``).""" diff --git a/packages/prime-rl-configs/src/prime_rl/configs/trainer.py b/packages/prime-rl-configs/src/prime_rl/configs/trainer.py index f3fa658a44..bfc43e5a32 100644 --- a/packages/prime-rl-configs/src/prime_rl/configs/trainer.py +++ b/packages/prime-rl-configs/src/prime_rl/configs/trainer.py @@ -10,6 +10,7 @@ FileMonitorConfig, HeartbeatConfig, MetricsServerConfig, + MultimodalConfig, TrainerLogConfig, TransportConfig, WandbConfig, @@ -21,6 +22,7 @@ AttnImplementation: TypeAlias = Literal["flash_attention_2", "flash_attention_3", "flash_attention_4", "auto"] EPCommBackend: TypeAlias = Literal["torch", "deepep"] +MissingMMImagePolicy: TypeAlias = Literal["error", "placeholder_zero_loss"] class GCConfig(BaseConfig): @@ -628,6 +630,12 @@ class TrainerConfig(BaseConfig): max_concurrent_runs: int = Field(1, ge=1) """Maximum number of concurrent runs to allow. If 1, only one run may run at a time.""" + missing_mm_image_policy: MissingMMImagePolicy = "placeholder_zero_loss" + """Policy when raw multimodal image files disappear before trainer materialization. ``placeholder_zero_loss`` warns, synthesizes zero-valued image tensors with the original descriptor geometry, and masks out the affected microbatch loss; ``error`` preserves fail-fast behavior.""" + + multimodal: MultimodalConfig = MultimodalConfig() + """Raw multimodal image offload settings shared with orchestrator and inference.""" + enable_token_export: bool = False """Opt-in per-token JSONL export for rollout debugging. When enabled, writes token ids and aligned trainer metrics after each forward pass.""" diff --git a/packages/prime-rl-configs/src/prime_rl/utils/validation.py b/packages/prime-rl-configs/src/prime_rl/utils/validation.py index 6dac87c12e..c1b04cf9af 100644 --- a/packages/prime-rl-configs/src/prime_rl/utils/validation.py +++ b/packages/prime-rl-configs/src/prime_rl/utils/validation.py @@ -132,6 +132,7 @@ def propagate(shared_path: str, *targets: str) -> None: # Top-level scalars. propagate("max_steps", "trainer.max_steps", "orchestrator.max_steps") propagate("seq_len", "trainer.model.seq_len", "orchestrator.seq_len") + propagate("multimodal", "trainer.multimodal", "orchestrator.multimodal", "inference.multimodal") # [slurm] → inference: a multi-node RL run drives its inference deployment under # the same SLURM allocation, so the nested inference inherits [slurm]. This is diff --git a/skills/training/monitor-run/SKILL.md b/skills/training/monitor-run/SKILL.md index 45d9abf92f..c88be60302 100644 --- a/skills/training/monitor-run/SKILL.md +++ b/skills/training/monitor-run/SKILL.md @@ -165,6 +165,38 @@ A few warnings are normal. Escalate when errors are persistent, growing, or hit - **Trainer**: NCCL/CUDA errors, OOM, NaN loss or gradients. - **Inference**: NCCL/CUDA errors, OOM, request timeouts. +### Multimodal image offload checks + +v1 multimodal RL offloads images exactly once, at verifiers ingress: every image +content part is rewritten to a `file://` asset under the run image directory +before rendering, and renderers/inference/trainer all work from those refs. A +`data:` URL reaching a renderer ("requires offloaded file:// image assets") +means ingress was bypassed. + +- The image directory comes from `[multimodal].offload_dir` in the resolved + config; unset, it defaults to a run-scoped path (`{output_dir}/assets/images` + or the hosted `RUN_ID` path). The launcher exports it to the orchestrator as + `VF_RENDERER_IMAGE_OFFLOAD_DIR` (protected — not settable via `env_vars`). +- While multimodal rollouts are in flight, image files should accumulate under + that directory. Zero files means the offload path isn't being exercised or + image preparation failed before request submission. +- Inference rejects bad refs with `invalid_mm_image_ref` 400s (hash mismatch, + fingerprint mismatch, unreadable asset) — grep the inference log. +- Inference caches materialized refs and logs + `mm materialize cache: hits=X misses=Y hit_rate=Z% bytes=A/B evictions=C` + every 1000 lookups. Hit rate should climb after turn 1 of multi-turn + multimodal rollouts; a stuck-at-zero hit rate with repeat images means the + cache is disabled or thrashing (sized by `PRIME_RL_MM_MATERIALIZE_CACHE_GB`, + default 2.0, `0` disables). +- The orchestrator raises on placeholder/token drift ("does not cover + image-typed tokens") before a sample ships — treat any occurrence as a bug, + not noise. +- Trainer metrics: `mm/images_materialized`, `time/mm_materialize`, and + `mm/images_placeholdered`. A nonzero placeholder count means image files + disappeared before materialization (the batch trains with zero-loss + placeholders and logs "raw image materialization missing image(s)") — check + whether something cleaned the offload directory mid-run. + ### Process tree All processes use `setproctitle` so they're visible in `ps`/`htop`/`pstree`: diff --git a/src/prime_rl/entrypoints/rl.py b/src/prime_rl/entrypoints/rl.py index 1c00ee4a74..9122923b1c 100644 --- a/src/prime_rl/entrypoints/rl.py +++ b/src/prime_rl/entrypoints/rl.py @@ -35,6 +35,7 @@ monitor_process, set_proc_title, ) +from prime_rl.utils.run_assets import build_run_asset_env RL_TOML = "rl.toml" RL_SBATCH = "rl.sbatch" @@ -128,6 +129,8 @@ def rl_local(config: RLConfig): "WANDB_SHARED_MODE": "1", "WANDB_SHARED_RUN_ID": os.environ.get("WANDB_SHARED_RUN_ID", uuid.uuid4().hex), } + inherited_env = dict(os.environ) + writer_run_asset_env = build_run_asset_env(config.orchestrator.output_dir, multimodal=config.multimodal) # Validate client port matches inference server port if config.inference is not None and not config.orchestrator.model.client.is_elastic: @@ -173,7 +176,7 @@ def sigterm_handler(signum, frame): inference_process = Popen( inference_cmd, env={ - **os.environ, + **inherited_env, **DEFAULT_COMMON_ENV_VARS, **DEFAULT_INFERENCE_ENV_VARS, **config.env_vars, @@ -228,7 +231,8 @@ def sigterm_handler(signum, frame): stdout=log_file, stderr=log_file, env={ - **os.environ, + **inherited_env, + **writer_run_asset_env, **DEFAULT_COMMON_ENV_VARS, "LOGURU_FORCE_COLORS": "1", "WANDB_PROGRAM": "uv run rl", @@ -277,7 +281,7 @@ def sigterm_handler(signum, frame): trainer_process = Popen( trainer_cmd, env={ - **os.environ, + **inherited_env, **DEFAULT_COMMON_ENV_VARS, **DEFAULT_TRAINER_ENV_VARS, "LOGURU_FORCE_COLORS": "1", @@ -375,6 +379,9 @@ def write_slurm_script(config: RLConfig, config_dir: Path, script_path: Path) -> kv_offload_disk_path=str(offload.disk.path) if (is_mooncake and offload.disk is not None) else "", kv_offload_device_name=offload.device_name if is_mooncake else "", ) + image_offload_dir = ( + os.path.expanduser(str(config.multimodal.offload_dir)) if config.multimodal.offload_dir is not None else "" + ) # Per-component env vars: launcher defaults (shared + multi-node-specific) with the # user's config merged on top. Runtime wiring stays in the template. @@ -396,6 +403,7 @@ def write_slurm_script(config: RLConfig, config_dir: Path, script_path: Path) -> **config.slurm.template_vars, config_path=config_dir / RL_TOML, output_dir=config.output_dir, + image_offload_dir=image_offload_dir, gpus_per_node=config.deployment.gpus_per_node, ) elif config.inference is not None and config.inference.deployment.type == "disaggregated": @@ -407,6 +415,7 @@ def write_slurm_script(config: RLConfig, config_dir: Path, script_path: Path) -> config_dir=config_dir, output_dir=config.output_dir, orchestrator_output_dir=config.orchestrator.output_dir, + image_offload_dir=image_offload_dir, num_train_nodes=config.deployment.num_train_nodes, num_infer_nodes=infer_deploy.num_nodes * config.deployment.num_infer_replicas, nodes_per_infer_replica=infer_deploy.num_nodes, @@ -446,6 +455,7 @@ def write_slurm_script(config: RLConfig, config_dir: Path, script_path: Path) -> config_dir=config_dir, # TODO: should prob have each subconfig path separately output_dir=config.output_dir, orchestrator_output_dir=config.orchestrator.output_dir, + image_offload_dir=image_offload_dir, num_train_nodes=config.deployment.num_train_nodes, num_infer_nodes=config.deployment.total_infer_nodes, nodes_per_infer_replica=config.deployment.infer_nodes_per_replica, diff --git a/src/prime_rl/inference/vllm/serving_tokens.py b/src/prime_rl/inference/vllm/serving_tokens.py index e14a5ac83e..67bd910ba6 100644 --- a/src/prime_rl/inference/vllm/serving_tokens.py +++ b/src/prime_rl/inference/vllm/serving_tokens.py @@ -4,7 +4,8 @@ ``vllm.entrypoints.scale_out.token_in_token_out.serving.ServingTokens`` that covers prefix-cache salting, lora dispatch, multimodal features, prompt logprobs, priority, ``data_parallel_rank`` header routing and server-side ``max_tokens`` -defaulting. We subclass it for the bits still missing from the upstream handler: +defaulting. We subclass it for prime-RL behavior that is still missing or +customized: 1. ``data_parallel_rank`` routing — read from the ``X-data-parallel-rank`` header and forwarded to ``engine_client.generate``. Upstream ``ServingTokens`` @@ -15,7 +16,12 @@ decisions, surface them as base64 raw-byte payloads without requiring a vLLM source fork. -3. Server-side ``max_tokens`` defaulting — upstream ``ServingTokens`` now applies +3. Raw image refs for multimodal rollouts — renderers send a lightweight raw + descriptor ref at every image slot (current and prior turns alike). This + handler materializes every ref through multimodal adapters before vLLM sees + the request. + +4. Server-side ``max_tokens`` defaulting — upstream ``ServingTokens`` now applies this itself (via ``GenerateRequest.is_sampling_param_provided`` + ``get_max_tokens``); we keep an equivalent guard so callers that omit ``max_tokens`` don't truncate at vLLM's 16-token ``SamplingParams`` default. @@ -26,8 +32,16 @@ from __future__ import annotations -from collections.abc import AsyncGenerator, AsyncIterable -from functools import cached_property +import asyncio +import hashlib +import logging +import os +from collections import OrderedDict +from collections.abc import AsyncGenerator, AsyncIterable, Callable +from dataclasses import dataclass +from functools import cached_property, lru_cache +from http import HTTPStatus +from io import BytesIO from typing import Any from fastapi import Request @@ -44,10 +58,23 @@ ) from vllm.entrypoints.scale_out.token_in_token_out.serving import ServingTokens from vllm.entrypoints.serve.utils.api_utils import get_max_tokens +from vllm.multimodal.cache import MultiModalCache from vllm.outputs import RequestOutput from vllm.sampling_params import RequestOutputKind, SamplingParams from prime_rl.inference.vllm.routed_experts import RoutedExpertsCapture +from prime_rl.multimodal.registry import get_multimodal_adapter +from prime_rl.multimodal.schema import RawMMItem +from prime_rl.utils.mm import file_uri_to_path + +logger = logging.getLogger(__name__) + + +@dataclass +class _MMImageRefError(Exception): + message: str + err_type: str = "invalid_mm_image_ref" + status_code: HTTPStatus = HTTPStatus.BAD_REQUEST class PrimeRlGenerateResponseChoice(GenerateResponseChoice): @@ -147,8 +174,280 @@ async def _client_set_max_tokens(raw_request: Request | None) -> bool: return isinstance(sp, dict) and "max_tokens" in sp +@lru_cache(maxsize=8) +def _load_image_processor(model_name: str, trust_remote_code: bool): + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=trust_remote_code) + image_processor = getattr(processor, "image_processor", None) + if image_processor is None: + raise ValueError(f"{model_name!r} does not expose an image_processor") + return image_processor + + +def _parse_raw_image_ref(raw_ref: str, *, feature_modality: str, mm_hash: str): + from renderers.mm_store import split_raw_mm_ref + + try: + ref = split_raw_mm_ref(raw_ref) + except ValueError as exc: + raise _MMImageRefError(str(exc)) from exc + + if ref.modality != feature_modality: + raise _MMImageRefError(f"Expected feature modality {feature_modality!r}, got {ref.modality!r}") + if ref.mm_hash != mm_hash: + raise _MMImageRefError(f"Expected image hash {mm_hash}, got {ref.mm_hash}") + return ref + + +def _read_verified_raw_image(ref) -> bytes: + try: + raw = file_uri_to_path(ref.raw_image_uri).read_bytes() + except OSError as exc: + raise _MMImageRefError(f"Unable to read raw image asset {ref.raw_image_uri!r}: {exc}") from exc + + actual_hash = hashlib.sha256(raw).hexdigest()[:32] + if actual_hash != ref.mm_hash: + raise _MMImageRefError(f"Raw image hash mismatch: expected {ref.mm_hash}, got {actual_hash}") + return raw + + +def _decode_raw_image(raw: bytes, *, raw_image_uri: str): + from PIL import Image + + try: + return Image.open(BytesIO(raw)).convert("RGB") + except OSError as exc: + raise _MMImageRefError(f"Unable to decode raw image asset {raw_image_uri!r}: {exc}") from exc + + +def _materialize_raw_image_ref_sync( + raw_ref: str, + *, + feature_modality: str, + mm_hash: str, + expected_placeholder_length: int, + processor_model_name: str, + trust_remote_code: bool, +): + ref = _parse_raw_image_ref(raw_ref, feature_modality=feature_modality, mm_hash=mm_hash) + raw = _read_verified_raw_image(ref) + image = _decode_raw_image(raw, raw_image_uri=ref.raw_image_uri) + image_processor = _load_image_processor(processor_model_name, trust_remote_code) + item = RawMMItem( + modality=ref.modality, + family=ref.family, + layout_fingerprint=ref.fingerprint, + raw_image_uri=ref.raw_image_uri, + payload=dict(ref.payload), + raw_ref=raw_ref, + ) + try: + adapter = get_multimodal_adapter(ref.family) + return adapter.materialize_for_vllm( + image_processor, + item, + image, + expected_placeholder_length, + ) + except (TypeError, ValueError) as exc: + raise _MMImageRefError(str(exc)) from exc + + +# (raw_ref_digest, feature_modality, mm_hash, expected_placeholder_length, +# processor_model_name, trust_remote_code). The digest keeps keys small while +# ensuring a distinct descriptor can never alias an already-validated cache +# entry, even when its outer hash/placeholder metadata is forged or stale. +_MaterializeKey = tuple[str, str, str, int, str, bool] + +_MM_MATERIALIZE_CACHE_GB_ENV = "PRIME_RL_MM_MATERIALIZE_CACHE_GB" +_MM_MATERIALIZE_LOG_EVERY = 1000 + + +class _MaterializedRefCache: + """Byte-bounded LRU of materialized raw image refs, with single-flight misses. + + Every request carries a ref for every image in its prompt (prior turns included), + so multi-turn rollouts re-materialize the same images once per turn per rollout — + this cache turns those repeats into lookups. Keys are content-addressed, so + entries can only go cold, never stale: a post-eviction request simply misses and + re-materializes from the durable ``file://`` asset. + + All mutation happens on the event loop thread (materialization itself runs in a + worker thread via ``asyncio.to_thread``, but lookup/insertion/eviction happen in + the async caller) — so no lock is needed. Do not touch this cache from sync code. + + ``max_bytes == 0`` disables caching and single-flight entirely: every call runs + the materializer, byte-identical to the uncached path. + + Host-RAM note: this budget is additive to vLLM's own processor cache + (``mm_processor_cache_gb × (api_server_count + data_parallel_size)``). + """ + + def __init__(self, max_bytes: int) -> None: + self.max_bytes = max_bytes + self._items: OrderedDict[_MaterializeKey, tuple[Any, int]] = OrderedDict() + self._inflight: dict[_MaterializeKey, asyncio.Future] = {} + self._bytes = 0 + self.hits = 0 + self.misses = 0 + self.evictions = 0 + + async def get_or_materialize(self, key: _MaterializeKey, materialize_fn: Callable[[], Any]) -> Any: + if self.max_bytes == 0: + return await asyncio.to_thread(materialize_fn) + if key in self._items: + self._items.move_to_end(key) + self.hits += 1 + self._maybe_log() + return self._items[key][0] + if (inflight := self._inflight.get(key)) is not None: + self.hits += 1 + self._maybe_log() + return await asyncio.shield(inflight) + self.misses += 1 + self._maybe_log() + future: asyncio.Future = asyncio.get_running_loop().create_future() + self._inflight[key] = future + + async def _materialize_and_resolve() -> None: + try: + item = await asyncio.to_thread(materialize_fn) + except BaseException as exc: + # Never cache a failure: the exception propagates to every awaiter + # and the next request for this key retries cleanly. + future.set_exception(exc) + # A never-awaited errored future logs a spurious warning at GC. + future.exception() + else: + future.set_result(item) + self._insert(key, item) + finally: + del self._inflight[key] + + # The work runs as its own task and awaiters shield the shared future: + # a cancelled request (client disconnect) must neither poison the future + # for deduped awaiters nor cancel it out from under them. + asyncio.get_running_loop().create_task(_materialize_and_resolve()) + return await asyncio.shield(future) + + def _insert(self, key: _MaterializeKey, item: Any) -> None: + nbytes = MultiModalCache.get_item_size(item) + if nbytes > self.max_bytes: + # Don't churn the whole cache for one oversized entry. + return + self._items[key] = (item, nbytes) + self._bytes += nbytes + while self._bytes > self.max_bytes: + _, (_, evicted_bytes) = self._items.popitem(last=False) + self._bytes -= evicted_bytes + self.evictions += 1 + + def _maybe_log(self) -> None: + total = self.hits + self.misses + if total % _MM_MATERIALIZE_LOG_EVERY == 0: + logger.info( + "mm materialize cache: hits=%d misses=%d hit_rate=%.1f%% bytes=%d/%d evictions=%d", + self.hits, + self.misses, + 100.0 * self.hits / total, + self._bytes, + self.max_bytes, + self.evictions, + ) + + +def _raw_ref_payloads_for_feature( + features: Any, feature_modality: str, hashes: list[str] +) -> tuple[list[str], list[Any]]: + from renderers.mm_store import is_raw_mm_ref + + kwargs_data = features.kwargs_data + if kwargs_data is None or feature_modality not in kwargs_data: + raise _MMImageRefError(f"v1 raw multimodal: modality {feature_modality!r} arrived with no raw refs") + + raw_refs = kwargs_data[feature_modality] + placeholders = features.mm_placeholders.get(feature_modality) + if placeholders is None: + raise _MMImageRefError(f"v1 raw multimodal: modality {feature_modality!r} arrived with no placeholders") + if len(raw_refs) != len(hashes): + raise _MMImageRefError( + f"Multimodal kwargs/hash length mismatch for {feature_modality}: {len(raw_refs)} != {len(hashes)}" + ) + if len(placeholders) != len(hashes): + raise _MMImageRefError( + f"Multimodal placeholder/hash length mismatch for {feature_modality}: {len(placeholders)} != {len(hashes)}" + ) + if not all(is_raw_mm_ref(item) for item in raw_refs): + raise _MMImageRefError("v1 multimodal inference accepts raw descriptor refs only") + return raw_refs, placeholders + + +async def _decode_raw_mm_kwargs( + features: Any, + *, + processor_model_name: str, + trust_remote_code: bool, + cache: _MaterializedRefCache, +) -> dict[str, list[Any]]: + # Flatten across modalities so every image in the request materializes + # concurrently; single-flight in the cache dedupes identical refs across + # (and within) requests. Fresh lists per request — vLLM's cache-injection + # path replaces list elements in place, so never hand it cache-owned lists. + flat: list[tuple[str, str, str, Any]] = [] + for feature_modality, hashes in features.mm_hashes.items(): + raw_refs, placeholders = _raw_ref_payloads_for_feature(features, feature_modality, hashes) + flat.extend(zip([feature_modality] * len(hashes), raw_refs, hashes, placeholders, strict=True)) + + def _materialize(feature_modality: str, raw_ref: str, mm_hash: str, placeholder: Any): + return _materialize_raw_image_ref_sync( + raw_ref, + feature_modality=feature_modality, + mm_hash=mm_hash, + expected_placeholder_length=placeholder.length, + processor_model_name=processor_model_name, + trust_remote_code=trust_remote_code, + ) + + decoded = await asyncio.gather( + *( + cache.get_or_materialize( + ( + hashlib.sha256(raw_ref.encode("utf-8")).hexdigest(), + feature_modality, + mm_hash, + placeholder.length, + processor_model_name, + trust_remote_code, + ), + lambda fm=feature_modality, r=raw_ref, h=mm_hash, p=placeholder: _materialize(fm, r, h, p), + ) + for feature_modality, raw_ref, mm_hash, placeholder in flat + ) + ) + + mm_kwargs: dict[str, list[Any]] = {feature_modality: [] for feature_modality in features.mm_hashes} + for (feature_modality, _, _, _), item in zip(flat, decoded, strict=True): + mm_kwargs[feature_modality].append(item) + return mm_kwargs + + class PrimeRlServingTokens(ServingTokens): - """ServingTokens + DP-rank routing + compact routed experts + max_tokens defaulting.""" + """ServingTokens + DP-rank routing + routed experts + raw image refs + max_tokens defaulting.""" + + @cached_property + def _mm_materialize_cache(self) -> _MaterializedRefCache: + """Materialized-ref cache, sized by ``PRIME_RL_MM_MATERIALIZE_CACHE_GB`` + (float GiB, default 2.0, ``0`` disables — the kill switch: disabled is + byte-identical to the uncached path). + + A ``cached_property`` because ``custom_init_app_state`` grafts this + subclass via ``object.__new__`` + ``__dict__.update``, so ``__init__`` + never runs (see ``_max_tokens_defaults``). One frontend process serves + all DP ranks of an engine, so the cache is shared across ranks. + """ + gb = float(os.environ.get(_MM_MATERIALIZE_CACHE_GB_ENV, "2.0")) + return _MaterializedRefCache(max_bytes=int(gb * (1 << 30))) @cached_property def _max_tokens_defaults(self) -> tuple[dict, int | None]: @@ -198,27 +497,29 @@ async def serve_tokens( raw_request.state.request_metadata = request_metadata # Build the engine input — features-aware (MM) or text-only fallback. - # Identical to upstream so we keep tracking it. if features := request.features: - from vllm.entrypoints.scale_out.token_in_token_out.mm_serde import decode_mm_kwargs_item from vllm.inputs import mm_input - from vllm.multimodal.inputs import ( - MultiModalKwargsItem, - MultiModalKwargsItems, - PlaceholderRange, - ) + from vllm.multimodal.inputs import MultiModalKwargsItems, PlaceholderRange mm_placeholders = { modality: [PlaceholderRange(offset=p.offset, length=p.length) for p in ranges] for modality, ranges in features.mm_placeholders.items() } - mm_kwargs: dict[str, list[MultiModalKwargsItem | None]] = {} - if features.kwargs_data is not None: - for modality, items in features.kwargs_data.items(): - mm_kwargs[modality] = [decode_mm_kwargs_item(item) if item is not None else None for item in items] - else: - for modality, hashes in features.mm_hashes.items(): - mm_kwargs[modality] = [None] * len(hashes) + processor_model_name = getattr(self.model_config, "model", None) or model_name + trust_remote_code = bool(getattr(self.model_config, "trust_remote_code", False)) + try: + mm_kwargs = await _decode_raw_mm_kwargs( + features, + processor_model_name=processor_model_name, + trust_remote_code=trust_remote_code, + cache=self._mm_materialize_cache, + ) + except _MMImageRefError as exc: + return self.create_error_response( + message=exc.message, + err_type=exc.err_type, + status_code=exc.status_code, + ) engine_input = mm_input( prompt_token_ids=request.token_ids, mm_kwargs=MultiModalKwargsItems(mm_kwargs), diff --git a/src/prime_rl/multimodal/__init__.py b/src/prime_rl/multimodal/__init__.py new file mode 100644 index 0000000000..961b12ada0 --- /dev/null +++ b/src/prime_rl/multimodal/__init__.py @@ -0,0 +1,12 @@ +from prime_rl.multimodal.adapters.base import ForwardPolicy, MaterializedMM, MultimodalAdapter +from prime_rl.multimodal.registry import get_multimodal_adapter +from prime_rl.multimodal.schema import RawMMItem, parse_raw_mm_item + +__all__ = [ + "ForwardPolicy", + "MaterializedMM", + "MultimodalAdapter", + "RawMMItem", + "get_multimodal_adapter", + "parse_raw_mm_item", +] diff --git a/src/prime_rl/multimodal/adapters/__init__.py b/src/prime_rl/multimodal/adapters/__init__.py new file mode 100644 index 0000000000..453f5c39f7 --- /dev/null +++ b/src/prime_rl/multimodal/adapters/__init__.py @@ -0,0 +1,4 @@ +from prime_rl.multimodal.adapters.kimi_k25 import KimiK25Adapter +from prime_rl.multimodal.adapters.qwen_vl import QwenVLAdapter + +__all__ = ["KimiK25Adapter", "QwenVLAdapter"] diff --git a/src/prime_rl/multimodal/adapters/base.py b/src/prime_rl/multimodal/adapters/base.py new file mode 100644 index 0000000000..b746b9f90a --- /dev/null +++ b/src/prime_rl/multimodal/adapters/base.py @@ -0,0 +1,52 @@ +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING, Any, Protocol + +if TYPE_CHECKING: + import torch + from PIL.Image import Image + + from prime_rl.multimodal.schema import RawMMItem + + +@dataclass(frozen=True) +class ForwardPolicy: + pass_position_ids_with_mm: bool = True + requires_mm_token_type_ids: bool = False + + +@dataclass(frozen=True) +class MaterializedMM: + kwargs: dict[str, "torch.Tensor"] + forward_policy: ForwardPolicy + + +class MultimodalAdapter(Protocol): + family: str + forward_policy: ForwardPolicy + + def validate_item(self, item: "RawMMItem") -> None: ... + + def processor_fingerprint(self, image_processor: Any) -> str: ... + + def materialize_for_trainer( + self, + image_processor: Any, + items: list["RawMMItem"], + images: list["Image"], + ) -> MaterializedMM: ... + + def materialize_for_vllm( + self, + image_processor: Any, + item: "RawMMItem", + image: "Image", + expected_placeholder_length: int, + ) -> Any: ... + + def synthesize_placeholder( + self, + image_processor: Any, + items: list["RawMMItem"], + ) -> MaterializedMM | None: ... diff --git a/src/prime_rl/multimodal/adapters/kimi_k25.py b/src/prime_rl/multimodal/adapters/kimi_k25.py new file mode 100644 index 0000000000..4a2aba7aa9 --- /dev/null +++ b/src/prime_rl/multimodal/adapters/kimi_k25.py @@ -0,0 +1,183 @@ +from __future__ import annotations + +import math +from collections.abc import Mapping +from typing import Any + +from renderers.kimi_k25 import KimiK25ImageLayoutSpec + +from prime_rl.multimodal.adapters.base import ForwardPolicy, MaterializedMM +from prime_rl.multimodal.schema import RawMMItem + + +def _tensorize(value: Any): + import torch + + if isinstance(value, torch.Tensor): + return value.contiguous() + return torch.as_tensor(value).contiguous() + + +def _media_proc_cfg(image_processor: Any) -> Mapping[str, Any]: + cfg = getattr(image_processor, "media_proc_cfg", None) + if not isinstance(cfg, Mapping): + raise ValueError("Kimi image processor must expose media_proc_cfg") + return cfg + + +def _required_cfg(cfg: Mapping[str, Any], name: str) -> Any: + if name not in cfg: + raise ValueError(f"Kimi image processor media_proc_cfg is missing {name!r}") + return cfg[name] + + +def _optional_int(value: Any) -> int | None: + if value is None: + return None + return int(value) + + +def _float_triple(value: Any, *, name: str) -> tuple[float, float, float]: + if not isinstance(value, list | tuple) or len(value) != 3: + raise ValueError(f"Kimi image processor media_proc_cfg[{name!r}] must be a length-3 sequence") + return (float(value[0]), float(value[1]), float(value[2])) + + +def _processor_layout(image_processor: Any) -> KimiK25ImageLayoutSpec: + """Read the actual processor's layout; drift from the renderer's baked + layout surfaces as a fingerprint mismatch at materialization.""" + cfg = _media_proc_cfg(image_processor) + return KimiK25ImageLayoutSpec( + patch_size=int(_required_cfg(cfg, "patch_size")), + merge_kernel_size=int(_required_cfg(cfg, "merge_kernel_size")), + in_patch_limit=int(_required_cfg(cfg, "in_patch_limit")), + patch_limit_on_one_side=int(_required_cfg(cfg, "patch_limit_on_one_side")), + fixed_output_tokens=_optional_int(_required_cfg(cfg, "fixed_output_tokens")), + image_mean=_float_triple(_required_cfg(cfg, "image_mean"), name="image_mean"), + image_std=_float_triple(_required_cfg(cfg, "image_std"), name="image_std"), + ) + + +def _grid_payload(item: RawMMItem) -> list[int]: + grid = item.payload.get("grid_thws") + if grid is None: + raise ValueError("Kimi raw descriptor payload is missing grid_thws") + if not isinstance(grid, list | tuple): + raise ValueError(f"Invalid Kimi grid_thws: {grid!r}") + if len(grid) == 1 and isinstance(grid[0], list | tuple): + grid = grid[0] + if not isinstance(grid, list | tuple) or len(grid) != 3: + raise ValueError(f"Invalid Kimi grid_thws: {grid!r}") + out = [int(v) for v in grid] + if any(v <= 0 for v in out): + raise ValueError(f"Invalid Kimi grid_thws: {grid!r}") + return out + + +def _process_images(image_processor: Any, images: list[Any], *, return_tensors: str): + medias = [{"type": "image", "image": image} for image in images] + preprocess = getattr(image_processor, "preprocess", None) + if preprocess is None: + raise ValueError("Kimi image processor is missing preprocess") + return preprocess(medias, return_tensors=return_tensors) + + +class KimiK25Adapter: + family = "kimi_k25" + forward_policy = ForwardPolicy(pass_position_ids_with_mm=True) + + def validate_item(self, item: RawMMItem) -> None: + if item.family != self.family: + raise ValueError(f"Kimi adapter cannot handle family {item.family!r}") + _grid_payload(item) + + def processor_fingerprint(self, image_processor: Any) -> str: + from renderers.mm_store import image_layout_fingerprint + + layout = _processor_layout(image_processor) + return image_layout_fingerprint( + family=self.family, + patch_size=layout.patch_size, + merge_kernel_size=layout.merge_kernel_size, + in_patch_limit=layout.in_patch_limit, + patch_limit_on_one_side=layout.patch_limit_on_one_side, + fixed_output_tokens=layout.fixed_output_tokens, + image_mean=list(layout.image_mean), + image_std=list(layout.image_std), + ) + + def materialize_for_trainer( + self, + image_processor: Any, + items: list[RawMMItem], + images: list[Any], + ) -> MaterializedMM: + for item in items: + self.validate_item(item) + processed = _process_images(image_processor, images, return_tensors="pt") + tensors = {str(k): _tensorize(v) for k, v in dict(processed).items()} + if "grid_thws" not in tensors: + raise ValueError("Kimi processor did not return grid_thws") + actual_grids = tensors["grid_thws"].reshape(-1, 3).tolist() + for idx, (item, actual_grid) in enumerate(zip(items, actual_grids, strict=True)): + expected = _grid_payload(item) + if actual_grid != expected: + raise ValueError(f"Kimi grid mismatch at index {idx}: expected {expected}, got {actual_grid}") + return MaterializedMM(kwargs=tensors, forward_policy=self.forward_policy) + + def materialize_for_vllm( + self, + image_processor: Any, + item: RawMMItem, + image: Any, + expected_placeholder_length: int, + ) -> Any: + from vllm.multimodal.inputs import MultiModalFieldConfig, MultiModalKwargsItems + + self.validate_item(item) + actual_fingerprint = self.processor_fingerprint(image_processor) + if actual_fingerprint != item.layout_fingerprint: + raise ValueError( + f"Image layout fingerprint mismatch: expected {item.layout_fingerprint}, got {actual_fingerprint}" + ) + hf_inputs = _process_images(image_processor, [image], return_tensors="pt") + tensors = {str(k): _tensorize(v) for k, v in dict(hf_inputs).items()} + expected_grid = _grid_payload(item) + actual_grid = tensors["grid_thws"].reshape(-1, 3).tolist()[0] + if actual_grid != expected_grid: + raise ValueError(f"Kimi grid mismatch: expected {expected_grid}, got {actual_grid}") + if expected_placeholder_length != 1: + raise ValueError(f"Kimi image placeholder length mismatch: expected {expected_placeholder_length}, got 1") + grid_sizes = tensors["grid_thws"].reshape(-1, 3).prod(-1) + config_by_key = { + "pixel_values": MultiModalFieldConfig.flat_from_sizes("vision_chunk", grid_sizes), + "grid_thws": MultiModalFieldConfig.batched("vision_chunk"), + } + return MultiModalKwargsItems.from_hf_inputs(tensors, config_by_key)["vision_chunk"][0] + + def synthesize_placeholder( + self, + image_processor: Any, + items: list[RawMMItem], + ) -> MaterializedMM | None: + if not items: + return None + import torch + + layout = _processor_layout(image_processor) + grids: list[list[int]] = [] + pixel_values: list[torch.Tensor] = [] + for item in items: + self.validate_item(item) + grid = _grid_payload(item) + grids.append(grid) + pixel_values.append( + torch.zeros((math.prod(grid), 3, layout.patch_size, layout.patch_size), dtype=torch.float32) + ) + return MaterializedMM( + kwargs={ + "pixel_values": torch.cat(pixel_values, dim=0).contiguous(), + "grid_thws": torch.tensor(grids, dtype=torch.long), + }, + forward_policy=self.forward_policy, + ) diff --git a/src/prime_rl/multimodal/adapters/qwen_vl.py b/src/prime_rl/multimodal/adapters/qwen_vl.py new file mode 100644 index 0000000000..6adf9c0bfa --- /dev/null +++ b/src/prime_rl/multimodal/adapters/qwen_vl.py @@ -0,0 +1,167 @@ +from __future__ import annotations + +import math +from typing import Any + +from prime_rl.multimodal.adapters.base import ForwardPolicy, MaterializedMM +from prime_rl.multimodal.schema import RawMMItem + + +def _processor_value(processor: Any, name: str, *, size_key: str | None = None) -> int: + value = getattr(processor, name, None) + if value is None and size_key is not None: + size = getattr(processor, "size", None) + get_size_value = getattr(size, "get", None) + if callable(get_size_value): + value = get_size_value(size_key) + if value is None: + raise ValueError(f"Image processor is missing {name}") + return int(value) + + +def _tensorize(value: Any): + import torch + + if isinstance(value, torch.Tensor): + return value.contiguous() + return torch.as_tensor(value).contiguous() + + +def _grid_payload(item: RawMMItem) -> list[int]: + grid = item.payload.get("image_grid_thw") + if grid is None: + raise ValueError("Qwen raw descriptor payload is missing image_grid_thw") + if not isinstance(grid, list | tuple): + raise ValueError(f"Invalid Qwen image_grid_thw: {grid!r}") + if len(grid) == 1 and isinstance(grid[0], list | tuple): + grid = grid[0] + if not isinstance(grid, list | tuple) or len(grid) != 3: + raise ValueError(f"Invalid Qwen image_grid_thw: {grid!r}") + out = [int(v) for v in grid] + if any(v <= 0 for v in out): + raise ValueError(f"Invalid Qwen image_grid_thw: {grid!r}") + return out + + +def _patch_area(patch_size: Any) -> int: + if isinstance(patch_size, list | tuple): + return math.prod(int(dim) for dim in patch_size) + size = int(patch_size) + return size * size + + +def _temporal_patch_extent(temporal_patch_size: Any) -> int: + if isinstance(temporal_patch_size, list | tuple): + return math.prod(int(dim) for dim in temporal_patch_size) + return int(temporal_patch_size) + + +class QwenVLAdapter: + family = "qwen_vl" + forward_policy = ForwardPolicy( + pass_position_ids_with_mm=False, + requires_mm_token_type_ids=True, + ) + + def validate_item(self, item: RawMMItem) -> None: + if item.family != self.family: + raise ValueError(f"Qwen adapter cannot handle family {item.family!r}") + _grid_payload(item) + + def processor_fingerprint(self, image_processor: Any) -> str: + from renderers.mm_store import image_layout_fingerprint + + return image_layout_fingerprint( + family=self.family, + patch_size=_processor_value(image_processor, "patch_size"), + merge_size=_processor_value(image_processor, "merge_size"), + temporal_patch_size=_processor_value(image_processor, "temporal_patch_size"), + min_pixels=_processor_value(image_processor, "min_pixels", size_key="shortest_edge"), + max_pixels=_processor_value(image_processor, "max_pixels", size_key="longest_edge"), + ) + + def materialize_for_trainer( + self, + image_processor: Any, + items: list[RawMMItem], + images: list[Any], + ) -> MaterializedMM: + for item in items: + self.validate_item(item) + processed = image_processor(images=images, return_tensors="pt") + tensors = {str(k): _tensorize(v) for k, v in dict(processed).items()} + if "image_grid_thw" not in tensors: + raise ValueError("Qwen processor did not return image_grid_thw") + actual_grids = tensors["image_grid_thw"].tolist() + for idx, (item, actual_grid) in enumerate(zip(items, actual_grids, strict=True)): + expected = _grid_payload(item) + if actual_grid != expected: + raise ValueError(f"Image grid mismatch at index {idx}: expected {expected}, got {actual_grid}") + return MaterializedMM(kwargs=tensors, forward_policy=self.forward_policy) + + def materialize_for_vllm( + self, + image_processor: Any, + item: RawMMItem, + image: Any, + expected_placeholder_length: int, + ) -> Any: + from vllm.model_executor.models.qwen2_vl import _create_qwen2vl_field_factory + from vllm.multimodal.inputs import MultiModalKwargsItems + + self.validate_item(item) + actual_fingerprint = self.processor_fingerprint(image_processor) + if actual_fingerprint != item.layout_fingerprint: + raise ValueError( + f"Image layout fingerprint mismatch: expected {item.layout_fingerprint}, got {actual_fingerprint}" + ) + hf_inputs = image_processor(images=[image], return_tensors="pt") + merge_size = _processor_value(image_processor, "merge_size") + config_by_key = _create_qwen2vl_field_factory(merge_size)(hf_inputs) + mm_item = MultiModalKwargsItems.from_hf_inputs(hf_inputs, config_by_key)["image"][0] + expected_grid = _grid_payload(item) + actual_grid = mm_item["image_grid_thw"].data.tolist() + if actual_grid != expected_grid: + raise ValueError(f"Image grid mismatch: expected {expected_grid}, got {actual_grid}") + num_image_tokens = int(expected_grid[0] * expected_grid[1] * expected_grid[2] // (merge_size * merge_size)) + if expected_placeholder_length != num_image_tokens: + raise ValueError( + f"Image placeholder length mismatch: expected {expected_placeholder_length}, got {num_image_tokens}" + ) + return mm_item + + def placeholder_feature_dim(self, image_processor: Any) -> int: + patch_size = getattr(image_processor, "patch_size", None) + temporal_patch_size = getattr(image_processor, "temporal_patch_size", None) + image_mean = getattr(image_processor, "image_mean", None) + channels = len(image_mean) if image_mean is not None else getattr(image_processor, "num_channels", 3) + if patch_size is None or temporal_patch_size is None: + raise ValueError( + "Cannot synthesize raw image placeholders without image processor patch_size and temporal_patch_size" + ) + return int(channels) * _temporal_patch_extent(temporal_patch_size) * _patch_area(patch_size) + + def synthesize_placeholder( + self, + image_processor: Any, + items: list[RawMMItem], + ) -> MaterializedMM | None: + if not items: + return None + import torch + + feature_dim = self.placeholder_feature_dim(image_processor) + pixel_values: list[torch.Tensor] = [] + image_grid_thw: list[list[int]] = [] + for item in items: + self.validate_item(item) + grid = _grid_payload(item) + pixel_values.append(torch.zeros((math.prod(grid), feature_dim), dtype=torch.float32)) + image_grid_thw.append(grid) + return MaterializedMM( + kwargs={ + "pixel_values": torch.cat(pixel_values, dim=0).contiguous(), + "image_grid_thw": torch.tensor(image_grid_thw, dtype=torch.long), + }, + forward_policy=self.forward_policy, + ) diff --git a/src/prime_rl/multimodal/registry.py b/src/prime_rl/multimodal/registry.py new file mode 100644 index 0000000000..88ccab849f --- /dev/null +++ b/src/prime_rl/multimodal/registry.py @@ -0,0 +1,17 @@ +from __future__ import annotations + +from prime_rl.multimodal.adapters.base import MultimodalAdapter +from prime_rl.multimodal.adapters.kimi_k25 import KimiK25Adapter +from prime_rl.multimodal.adapters.qwen_vl import QwenVLAdapter + +_ADAPTERS: dict[str, MultimodalAdapter] = { + QwenVLAdapter.family: QwenVLAdapter(), + KimiK25Adapter.family: KimiK25Adapter(), +} + + +def get_multimodal_adapter(family: str) -> MultimodalAdapter: + try: + return _ADAPTERS[family] + except KeyError as exc: + raise NotImplementedError(f"No multimodal adapter registered for family {family!r}") from exc diff --git a/src/prime_rl/multimodal/schema.py b/src/prime_rl/multimodal/schema.py new file mode 100644 index 0000000000..0685274b20 --- /dev/null +++ b/src/prime_rl/multimodal/schema.py @@ -0,0 +1,64 @@ +from __future__ import annotations + +from collections.abc import Mapping +from dataclasses import dataclass +from typing import Any + +from renderers.mm_store import RAW_MM_ITEM_KIND + + +@dataclass(frozen=True) +class RawMMItem: + modality: str + family: str + layout_fingerprint: str + raw_image_uri: str + payload: dict[str, Any] + raw_ref: str | None = None + vllm_modality: str | None = None + + +def _descriptor_mapping(value: Any) -> Mapping[str, Any]: + if isinstance(value, Mapping): + return value + raise TypeError(f"v1 multimodal sidecars must be raw descriptor dicts, got {type(value).__name__}") + + +def _required_str(value: Mapping[str, Any], field: str) -> str: + item = value.get(field) + if isinstance(item, str) and item: + return item + raise ValueError(f"raw multimodal descriptor is missing {field}") + + +def _optional_str(value: Mapping[str, Any], field: str) -> str | None: + item = value.get(field) + if item is None or isinstance(item, str): + return item + raise ValueError(f"raw multimodal descriptor {field} must be a string when present") + + +def _payload(value: Mapping[str, Any]) -> dict[str, Any]: + payload = value.get("payload") + if not isinstance(payload, Mapping): + raise ValueError("raw multimodal descriptor payload must be a dict") + return {str(k): v for k, v in payload.items()} + + +def _validate_envelope(value: Mapping[str, Any]) -> None: + if value.get("kind") != RAW_MM_ITEM_KIND: + raise ValueError("raw multimodal descriptor is missing the common envelope kind") + + +def parse_raw_mm_item(value: Any) -> RawMMItem: + descriptor = _descriptor_mapping(value) + _validate_envelope(descriptor) + return RawMMItem( + modality=_required_str(descriptor, "modality"), + family=_required_str(descriptor, "family"), + layout_fingerprint=_required_str(descriptor, "layout_fingerprint"), + raw_image_uri=_required_str(descriptor, "raw_image_uri"), + payload=_payload(descriptor), + raw_ref=_optional_str(descriptor, "raw_ref"), + vllm_modality=_optional_str(descriptor, "vllm_modality"), + ) diff --git a/src/prime_rl/orchestrator/metrics.py b/src/prime_rl/orchestrator/metrics.py index ce860cb284..aacd5b13bd 100644 --- a/src/prime_rl/orchestrator/metrics.py +++ b/src/prime_rl/orchestrator/metrics.py @@ -91,6 +91,9 @@ class TimingMetrics(StatGroup): ``total`` is the per-rollout sum across all phases.""" PHASES = ("setup", "generation", "finalize", "scoring") + # Verifiers renamed its generation span to `agent`; the metric keeps the + # `generation` name so dashboards and the monitor-run skill stay stable. + TRACE_PHASES = {"generation": "agent"} @property def setup(self) -> Stat: @@ -98,18 +101,18 @@ def setup(self) -> Stat: @property def generation(self) -> Stat: - return Stat([r.timing.generation.duration for r in self.rollouts]) + return Stat([r.timing.agent.duration for r in self.rollouts]) @property def generation_model(self) -> Stat: """The share of the generation phase spent inside model calls (inference).""" - return Stat([r.timing.generation.model.duration for r in self.rollouts]) + return Stat([r.timing.agent.model.duration for r in self.rollouts]) @property def generation_harness(self) -> Stat: """The share of the generation phase spent outside model calls (harness, tools, user simulation).""" - return Stat([r.timing.generation.harness.duration for r in self.rollouts]) + return Stat([r.timing.agent.harness.duration for r in self.rollouts]) @property def finalize(self) -> Stat: @@ -121,7 +124,9 @@ def scoring(self) -> Stat: @property def total(self) -> Stat: - return Stat([sum(getattr(r.timing, p).duration for p in self.PHASES) for r in self.rollouts]) + return Stat( + [sum(getattr(r.timing, self.TRACE_PHASES.get(p, p)).duration for p in self.PHASES) for r in self.rollouts] + ) def stats(self) -> dict[str, Stat]: return { diff --git a/src/prime_rl/orchestrator/orchestrator.py b/src/prime_rl/orchestrator/orchestrator.py index e4d89eb816..15bef76abe 100644 --- a/src/prime_rl/orchestrator/orchestrator.py +++ b/src/prime_rl/orchestrator/orchestrator.py @@ -82,6 +82,7 @@ from prime_rl.utils.logger import format_time, get_logger, setup_logger from prime_rl.utils.monitor import setup_monitor from prime_rl.utils.pathing import get_log_dir, get_trace_path +from prime_rl.utils.run_assets import apply_run_asset_env from prime_rl.utils.usage_reporter import UsageReporter from prime_rl.utils.utils import ( clean_exit, @@ -1003,6 +1004,7 @@ async def run_orchestrator(config: OrchestratorConfig) -> None: """Top-level entrypoint. Wrapped in ``@clean_exit`` so wandb is flushed on exit (success or crash); keeps that out of the class. """ + apply_run_asset_env(config.output_dir, config.multimodal) await Orchestrator(config).start() diff --git a/src/prime_rl/orchestrator/trajectories.py b/src/prime_rl/orchestrator/trajectories.py index 8053453ac8..e62b47e13d 100644 --- a/src/prime_rl/orchestrator/trajectories.py +++ b/src/prime_rl/orchestrator/trajectories.py @@ -9,8 +9,8 @@ Training is renderer-only across every mode (RL/OPD student, SFT teacher), so every node always carries its tokens — no backfill needed. For multimodal rollouts the branch also carries -the images it introduced (`branch.multi_modal_data`), rebuilt here into the flat `mm_kwargs` / -`mm_token_type_ids` the trainer forwards. +raw image refs and renderer descriptors (`branch.multi_modal_data`), preserved here as +`mm_refs` for trainer-side materialization. """ from __future__ import annotations @@ -21,32 +21,9 @@ import verifiers.v1 as vf from prime_rl.transport import TrainingSample -from prime_rl.transport.types import EncodedTensor, RoutedExperts +from prime_rl.transport.types import MMRefs, RoutedExperts from prime_rl.utils.logger import get_logger - - -def _to_numpy(val) -> np.ndarray: - """A renderer mm item value (torch tensor or numpy array) -> a contiguous numpy array.""" - if hasattr(val, "detach"): # torch tensor - val = val.detach().cpu().numpy() - return np.ascontiguousarray(val) - - -def _encode_mm_kwargs(mm_items: dict[str, list[dict]]) -> dict[str, EncodedTensor] | None: - """Concatenate the branch's per-image renderer items into the flat `mm_kwargs` the trainer - forwards — one `EncodedTensor` per kwarg key (e.g. `pixel_values`, `image_grid_thw`), images - cat'd along dim 0 in branch token order. Model-agnostic: the keys are whatever the processor - emits. Returns None when there are no items.""" - bins: dict[str, list[np.ndarray]] = {} - for items in mm_items.values(): # per modality - for item in items: # per image - for key, val in item.items(): - bins.setdefault(key, []).append(_to_numpy(val)) - encoded: dict[str, EncodedTensor] = {} - for key, arrs in bins.items(): - arr = np.concatenate(arrs, axis=0) - encoded[key] = EncodedTensor(dtype=str(arr.dtype), shape=list(arr.shape), data=arr.tobytes()) - return encoded or None +from prime_rl.utils.mm import build_mm_refs def _encode_routed_experts(arr: np.ndarray | None, num_tokens: int) -> RoutedExperts | None: @@ -66,6 +43,23 @@ def _encode_routed_experts(arr: np.ndarray | None, num_tokens: int) -> RoutedExp return RoutedExperts(data=arr.tobytes(), shape=list(arr.shape), dtype=str(arr.dtype)) +def _validate_image_spans(mm_refs: MMRefs, mm_token_type_ids: list[int]) -> None: + """Every image ref's placeholder span must land on image-typed tokens. + + Placeholder offsets flow through the renderer, bridge extension, and node + attribution before arriving here — and the trainer truncates on them — so + any drift anywhere upstream must fail loudly before the sample ships. + """ + for image in mm_refs.images: + span = mm_token_type_ids[image.offset : image.offset + image.length] + if len(span) != image.length or any(t != 1 for t in span): + raise ValueError( + f"Raw image placeholder [{image.offset}, {image.offset + image.length}) does not " + f"cover image-typed tokens (branch length {len(mm_token_type_ids)}) — placeholder " + "offsets have drifted from the branch token stream" + ) + + def iter_trainable_branches(trace: vf.Trace) -> Iterator[tuple[vf.Branch, list[bool]]]: """Yield each branch that yields a training sample, with its trainable-token mask. @@ -101,21 +95,23 @@ def trace_to_samples( `branch.sampled_mask` / `branch.logprobs`), so a sample carries it directly: `mask` marks the trainable (model-sampled) tokens, the context tokens between completions stay masked out. Errored rollouts are dropped upstream (`TrainSink.process_rollout`), so no error - handling happens here. A branch carrying images also gets `mm_kwargs` (the concatenated - pixel tensors) and `mm_token_type_ids` (the renderer's `mm_token_type_id_map` applied to - the branch tokens). Branches with no sampled tokens (e.g. an openai client carrying none) - yield nothing. + handling happens here. A branch carrying images also gets `mm_refs` (raw image URIs + + JSON-safe renderer metadata) and `mm_token_type_ids` (the renderer's + `mm_token_type_id_map` applied to the branch tokens). Branches with no sampled tokens + (e.g. an openai client carrying none) yield nothing. """ samples: list[TrainingSample] = [] for branch, mask in iter_trainable_branches(trace): token_ids = branch.token_ids - mm_kwargs: dict[str, EncodedTensor] | None = None + mm_refs: MMRefs | None = None mm_token_type_ids: list[int] | None = None mmd = branch.multi_modal_data if mmd is not None: - mm_kwargs = _encode_mm_kwargs(mmd.mm_items) + mm_refs = build_mm_refs(mmd) mapping = mm_token_type_ids_mapping or {} mm_token_type_ids = [mapping.get(t, 0) for t in token_ids] + if mm_refs is not None and mapping: + _validate_image_spans(mm_refs, mm_token_type_ids) samples.append( TrainingSample( token_ids=token_ids, @@ -123,7 +119,7 @@ def trace_to_samples( logprobs=branch.logprobs, temperatures=[], # filled by TrainSink.process_group env_name=env_name, - mm_kwargs=mm_kwargs, + mm_refs=mm_refs, mm_token_type_ids=mm_token_type_ids, routed_experts=_encode_routed_experts(branch.routed_experts, len(token_ids)), ) diff --git a/src/prime_rl/templates/multi_node_rl.sbatch.j2 b/src/prime_rl/templates/multi_node_rl.sbatch.j2 index 2db4287d36..9225e6b498 100755 --- a/src/prime_rl/templates/multi_node_rl.sbatch.j2 +++ b/src/prime_rl/templates/multi_node_rl.sbatch.j2 @@ -59,6 +59,18 @@ export PROJECT_DIR={{ project_dir }} export CONFIG_DIR={{ config_dir }} export OUTPUT_DIR={{ output_dir }} export ORCHESTRATOR_OUTPUT_DIR={{ orchestrator_output_dir }} +{% if image_offload_dir %} +export VF_RENDERER_IMAGE_OFFLOAD_DIR="{{ image_offload_dir }}" +{% else %} +if [ -z "${VF_RENDERER_IMAGE_OFFLOAD_DIR:-}" ]; then + if [ -n "${RUN_ID:-}" ]; then + RUN_ASSET_ID="${RUN_ID#run_}" + export VF_RENDERER_IMAGE_OFFLOAD_DIR="/data/outputs/run_${RUN_ASSET_ID}/assets/images" + else + export VF_RENDERER_IMAGE_OFFLOAD_DIR="$ORCHESTRATOR_OUTPUT_DIR/assets/images" + fi +fi +{% endif %} mkdir -p $OUTPUT_DIR/logs/trainer $OUTPUT_DIR/logs/inference rm -f $OUTPUT_DIR/logs/inference/*.log ln -sfn trainer/node_0.log $OUTPUT_DIR/logs/trainer.log diff --git a/src/prime_rl/trainer/batch.py b/src/prime_rl/trainer/batch.py index 4eb8ff4baa..bb3eb257fd 100644 --- a/src/prime_rl/trainer/batch.py +++ b/src/prime_rl/trainer/batch.py @@ -2,10 +2,11 @@ from collections.abc import Callable, Sequence from dataclasses import dataclass +import msgspec import numpy as np from prime_rl.trainer.utils import balanced_partition -from prime_rl.transport.types import EncodedTensor, MicroBatch, RoutedExperts, TrainingSample +from prime_rl.transport.types import MicroBatch, MMImageRef, MMRefs, RoutedExperts, TrainingSample # Backfill value per component weight stream when a packed sample doesn't # carry it: absent rl means weight 1.0 on the loss mask, absent ce/ref_kl @@ -42,56 +43,23 @@ def _pad_routed_experts(micro_batch: MicroBatch, padding_size: int) -> None: routed_experts.shape[0] += padding_size -def _slice_encoded(tensor: EncodedTensor, n_rows: int) -> EncodedTensor: - """First `n_rows` rows of a dim-0-stacked encoded tensor (e.g. pixel_values, image_grid_thw).""" - row = int(np.prod(tensor.shape[1:])) if len(tensor.shape) > 1 else 1 - itemsize = np.dtype(tensor.dtype).itemsize - return EncodedTensor( - dtype=tensor.dtype, - shape=[n_rows, *tensor.shape[1:]], - data=tensor.data[: n_rows * row * itemsize], - ) - - -def _truncate_mm( - mm_token_type_ids: list[int], mm_kwargs: dict[str, EncodedTensor], seq_len: int -) -> tuple[int, dict[str, EncodedTensor] | None]: - """Truncating a sample must not split an image's placeholder block, else the surviving image - token count no longer matches the image embeddings in `mm_kwargs`. Returns the cut point - (<= seq_len, never inside an image block) and `mm_kwargs` sliced to the images whose - placeholders fully survive (None if no image survives).""" - grid = np.frombuffer(bytearray(mm_kwargs["image_grid_thw"].data), dtype=mm_kwargs["image_grid_thw"].dtype).reshape( - mm_kwargs["image_grid_thw"].shape - ) - patches_per_image = [int(g.prod()) for g in grid] - total_patches = mm_kwargs["pixel_values"].shape[0] - total_tokens = sum(1 for t in mm_token_type_ids if t) - ppt = total_patches // total_tokens if total_tokens else 1 # patches per token (merge^2) - tokens_per_image = [p // ppt for p in patches_per_image] - - surviving = sum(1 for t in mm_token_type_ids[:seq_len] if t) - kept = acc = 0 - for n in tokens_per_image: - if acc + n > surviving: - break - acc += n - kept += 1 - if acc == surviving: - cut = seq_len # surviving image tokens are exactly `kept` whole images - else: - # `surviving` lands inside image `kept`; cut to its first placeholder, dropping it. - seen, cut = 0, seq_len - for i, t in enumerate(mm_token_type_ids): - if t: - seen += 1 - if seen == acc + 1: - cut = i - break - if not kept: +def _truncate_mm_refs(mm_refs: MMRefs, seq_len: int) -> tuple[int, MMRefs | None]: + """Return a token cut that never splits an image placeholder, plus the surviving refs.""" + cut, kept = seq_len, 0 + for image in mm_refs.images: # token order, non-overlapping — enforced by build_mm_refs + if image.offset + image.length <= seq_len: + kept += 1 + continue + if image.offset < seq_len: + cut = image.offset + break + if cut == 0: + raise ValueError(f"Cannot truncate multimodal sample: leading image does not fit in seq_len={seq_len}") + if kept == len(mm_refs.images): + return seq_len, mm_refs + if kept == 0: return cut, None - kept_patches = sum(patches_per_image[:kept]) - sliced = {k: _slice_encoded(v, kept if k == "image_grid_thw" else kept_patches) for k, v in mm_kwargs.items()} - return cut, sliced + return cut, MMRefs(images=mm_refs.images[:kept]) def multimodal_sample_error(sample: TrainingSample) -> str | None: @@ -101,6 +69,10 @@ def multimodal_sample_error(sample: TrainingSample) -> str | None: "mm_token_type_ids length must match token_ids length " f"({len(mm_token_type_ids)} != {len(sample.token_ids)})" ) + if sample.mm_refs is not None and mm_token_type_ids is None: + # The orchestrator always stamps mm_token_type_ids alongside mm_refs; the + # trainer's image-boundary truncation and forward policies rely on them. + return "raw multimodal samples require mm_token_type_ids" if sample.mm_kwargs is not None and "image_grid_thw" in sample.mm_kwargs and mm_token_type_ids is None: return "image_grid_thw multimodal samples require mm_token_type_ids" return None @@ -134,7 +106,9 @@ def prepare_sample(training_example: TrainingSample, seq_len: int) -> MicroBatch ref_kl_weights = list(training_example.ref_kl_weights) if training_example.ref_kl_weights is not None else None position_ids = list(range(len(input_ids))) mm_token_type_ids = training_example.mm_token_type_ids - mm_kwargs = training_example.mm_kwargs + if training_example.mm_kwargs is not None: + raise ValueError("Processed multimodal mm_kwargs are unsupported in v1; use raw mm_refs") + mm_refs = training_example.mm_refs assert training_example.env_name != "all", "env_name='all' is reserved for aggregate metric keys" env_names = [training_example.env_name] * len(input_ids) @@ -149,11 +123,9 @@ def prepare_sample(training_example: TrainingSample, seq_len: int) -> MicroBatch ) if len(input_ids) > seq_len: - # Multimodal: never split an image's placeholder block — cut to a whole-image boundary - # and slice mm_kwargs to match, so image-token count == image-embedding count. cut = seq_len - if mm_token_type_ids is not None and mm_kwargs is not None: - cut, mm_kwargs = _truncate_mm(mm_token_type_ids, mm_kwargs, seq_len) + if mm_refs is not None: + cut, mm_refs = _truncate_mm_refs(mm_refs, seq_len) input_ids = input_ids[:cut] loss_mask = loss_mask[:cut] inference_logprobs = inference_logprobs[:cut] @@ -214,7 +186,7 @@ def prepare_sample(training_example: TrainingSample, seq_len: int) -> MicroBatch routed_experts=routed_experts, mm_token_type_ids=mm_token_type_ids, env_names=env_names, - mm_kwargs=mm_kwargs, + mm_refs=mm_refs, rl_weights=rl_weights, ce_weights=ce_weights, ref_kl_weights=ref_kl_weights, @@ -224,7 +196,16 @@ def prepare_sample(training_example: TrainingSample, seq_len: int) -> MicroBatch def _is_multimodal_sample(sample: MicroBatch) -> bool: """Check if a sample contains multimodal data (images).""" - return sample.mm_kwargs is not None + return sample.mm_refs is not None or sample.mm_kwargs is not None + + +def _mm_refs_family(mm_refs: MMRefs) -> str | None: + """The adapter family of a sample's raw image refs. + + ``build_mm_refs`` validates every descriptor and the materializer enforces + exactly one family per micro batch, so the first image's family stands for + the sample.""" + return mm_refs.images[0].item.get("family") if mm_refs.images else None @dataclass @@ -268,6 +249,12 @@ def can_add(self, sample: MicroBatch, max_seq_len: int, lora_idx: int) -> bool: if self.first_lora_idx != lora_idx: return False if existing_mm_sample is not None and sample_is_mm: + if (existing_mm_sample.mm_refs is None) != (sample.mm_refs is None): + return False + if sample.mm_refs is not None: + # Raw refs materialize downstream through exactly one adapter family + # per micro batch; within a family, grids and image sizes vary freely. + return _mm_refs_family(existing_mm_sample.mm_refs) == _mm_refs_family(sample.mm_refs) dst = existing_mm_sample.mm_kwargs src = sample.mm_kwargs assert dst is not None and src is not None, "multimodal samples must carry mm_kwargs" @@ -327,10 +314,12 @@ def _materialize_bin(bin_content: _MicroBatchBin, num_loras: int) -> MicroBatch: streams: dict[str, list[float] | None] = {name: ([] if has_stream[name] else None) for name in STREAM_FILL} seq_lens: list[int] = [] routed_experts: RoutedExperts | None = None + mm_ref_images: list[MMImageRef] = [] lora_num_tokens = [0] * num_loras for lora_idx, sample in bin_content.samples: sample_len = len(sample.input_ids) + sample_start = len(input_ids) input_ids.extend(sample.input_ids) loss_mask.extend(sample.loss_mask) advantages.extend(sample.advantages) @@ -364,6 +353,11 @@ def _materialize_bin(bin_content: _MicroBatchBin, num_loras: int) -> MicroBatch: for key in mm_kwargs: mm_kwargs[key].data += sample.mm_kwargs[key].data mm_kwargs[key].shape[0] += sample.mm_kwargs[key].shape[0] + if sample.mm_refs is not None: + # Placeholder offsets are sample-relative; rebase them to the packed stream. + mm_ref_images.extend( + msgspec.structs.replace(image, offset=image.offset + sample_start) for image in sample.mm_refs.images + ) seq_lens.extend(sample.seq_lens) lora_num_tokens[lora_idx] += sample_len @@ -384,6 +378,7 @@ def _materialize_bin(bin_content: _MicroBatchBin, num_loras: int) -> MicroBatch: routed_experts=routed_experts, mm_token_type_ids=mm_token_type_ids, env_names=env_names, + mm_refs=MMRefs(images=mm_ref_images) if mm_ref_images else None, mm_kwargs=mm_kwargs, rl_weights=streams["rl_weights"], ce_weights=streams["ce_weights"], @@ -422,8 +417,9 @@ def packed_samples_into_micro_bs( With per-token temperatures, samples can be packed together regardless of their temperature values. Multimodal samples pack with text spans from the same run/LoRA and with - compatible eager ``mm_kwargs`` samples. Packed batches preserve sample - boundaries in ``seq_lens``. + same-family raw-ref samples (image ref offsets are rebased to the packed + stream in ``_materialize_bin``). Packed batches preserve sample boundaries + in ``seq_lens``. """ # Sort by (lora_idx, -length) for packing efficiency samples.sort(key=lambda x: (x[0], -len(x[1].input_ids))) diff --git a/src/prime_rl/trainer/model.py b/src/prime_rl/trainer/model.py index d2d6703819..34e03dd9a8 100644 --- a/src/prime_rl/trainer/model.py +++ b/src/prime_rl/trainer/model.py @@ -34,6 +34,7 @@ MXFP8Config, TokenizerConfig, ) +from prime_rl.multimodal.adapters.base import ForwardPolicy from prime_rl.trainer.distributed import DeepEPExpertParallel, MXFP8AllToAllExpertParallel from prime_rl.trainer.lora import apply_lora_to_model, freeze_all_except_lora_and_specified, strip_lora_from_state_dict from prime_rl.trainer.models import ( @@ -1373,12 +1374,14 @@ def forward( labels: Int[Tensor, "batch seq"] | None = None, temperature: Tensor | None = None, routed_experts: Int[Tensor, "batch seq layers topk"] | None = None, - # Generic multimodal kwargs (e.g. {"pixel_values": ..., - # "image_grid_thw": ...} for Qwen3-VL; just {"pixel_values": ...} - # for Gemma3). Passed straight through to ``model(**kwargs)`` so - # the model's HF forward signature is the schema. ``mm_token_type_ids`` - # is split out because it comes from the renderer rather than the processor. + # Generic multimodal kwargs materialized by the trainer's model processor + # (e.g. {"pixel_values": ..., "image_grid_thw": ...} for Qwen3-VL; just + # {"pixel_values": ...} for Gemma3). Passed straight through to + # ``model(**kwargs)`` so the model's HF forward signature is the schema. + # ``mm_token_type_ids`` is split out because it's prime-rl-computed from + # renderer token ids, not part of the processor's own output. mm_kwargs: dict[str, Tensor] | None = None, + mm_forward_policy: ForwardPolicy | None = None, mm_token_type_ids: Int[Tensor, "batch seq"] | None = None, # True when seq_lens holds the full pre-CP-shard document boundaries # (kept global because documents can straddle the shard cut). @@ -1390,14 +1393,19 @@ def forward( "temperature": temperature, } - if mm_kwargs: + if mm_kwargs is not None: # Forward the per-model multimodal tensors verbatim, plus the - # renderer-supplied ``mm_token_type_ids`` (renderer owns the - # token→modality mapping via ``mm_token_type_id_map``). + # token→modality map derived from renderer token ids. kwargs.update(mm_kwargs) if mm_token_type_ids is not None: kwargs["mm_token_type_ids"] = mm_token_type_ids - if "image_grid_thw" not in mm_kwargs: + # Callers without an adapter policy (SFT) fall back to key presence: + # models whose kwargs carry image_grid_thw (Qwen-VL family) build + # their own MRoPE position ids and must not receive packed 1D ones. + policy = mm_forward_policy or ForwardPolicy(pass_position_ids_with_mm="image_grid_thw" not in mm_kwargs) + if policy.requires_mm_token_type_ids and mm_token_type_ids is None: + raise ValueError("Multimodal forward policy requires mm_token_type_ids") + if policy.pass_position_ids_with_mm: kwargs["position_ids"] = position_ids else: kwargs["position_ids"] = position_ids diff --git a/src/prime_rl/trainer/rl/data.py b/src/prime_rl/trainer/rl/data.py index 1ad250cf72..5e98d9636a 100644 --- a/src/prime_rl/trainer/rl/data.py +++ b/src/prime_rl/trainer/rl/data.py @@ -1,3 +1,4 @@ +import time from collections.abc import Callable, Sequence from pathlib import Path from typing import TypedDict @@ -6,7 +7,8 @@ from jaxtyping import Bool, Float, Int from torch import Tensor -from prime_rl.configs.trainer import FakeDataLoaderConfig +from prime_rl.configs.trainer import FakeDataLoaderConfig, MissingMMImagePolicy +from prime_rl.multimodal.adapters.base import ForwardPolicy, MaterializedMM from prime_rl.trainer.rl.packer import BasePacker, setup_packer from prime_rl.trainer.runs import get_multi_run_manager from prime_rl.trainer.world import get_world @@ -16,6 +18,9 @@ TransportConfig, setup_micro_batch_receiver, ) +from prime_rl.transport.types import MMRefs +from prime_rl.utils.logger import get_logger +from prime_rl.utils.mm import RawImageMaterializer, missing_file_uris class TensorMicroBatch(TypedDict): @@ -39,12 +44,9 @@ class TensorMicroBatch(TypedDict): # MoE router replay routed_experts: Int[Tensor, "batch seq layers topk"] | None - # Generic multimodal kwargs — flat dict matching the model's forward - # signature (e.g. ``{"pixel_values": ..., "image_grid_thw": ...}`` for - # Qwen3-VL; ``{"pixel_values": ...}`` for Gemma3-VL). The trainer - # ``**`` -unpacks this into the forward call, so any HF VLM whose - # processor and forward agree on kwarg names works out of the box. + # Generic multimodal kwargs materialized by the trainer's model processor. mm_kwargs: dict[str, Tensor] | None + mm_forward_policy: ForwardPolicy | None # mm_token_type_ids: token type per token [batch seq], int64 (0=text, 1=image, 2=video) mm_token_type_ids: Int[Tensor, "batch seq"] | None @@ -59,6 +61,9 @@ class TensorMicroBatch(TypedDict): run_step: int | None +MaterializedMMParts = tuple[dict[str, Tensor] | None, ForwardPolicy | None] + + class FakeDataLoader: def __init__(self, config: FakeDataLoaderConfig, seq_len: int, dp_world_size: int): self.world = get_world() @@ -72,6 +77,9 @@ def __init__(self, config: FakeDataLoaderConfig, seq_len: int, dp_world_size: in self.generate_samples = config.generate_samples self.batch_counter = 0 self.multi_run_manager = get_multi_run_manager() + self.last_mm_materialize_time = 0.0 + self.last_mm_images_materialized = 0 + self.last_mm_images_placeholdered = 0 def wait_for_batch(self) -> None: return @@ -133,6 +141,7 @@ def _get_sample_micro_batch(self, generator: torch.Generator) -> TensorMicroBatc "seq_lens": torch.tensor(sequence_lengths, dtype=torch.long), "routed_experts": None, "mm_kwargs": None, + "mm_forward_policy": None, "mm_token_type_ids": None, "rl_weights": None, "ce_weights": None, @@ -166,6 +175,7 @@ def _get_micro_batch(self, generator: torch.Generator) -> TensorMicroBatch: "seq_lens": torch.tensor([self.seq_len], dtype=torch.long), "routed_experts": None, "mm_kwargs": None, + "mm_forward_policy": None, "mm_token_type_ids": None, "rl_weights": None, "ce_weights": None, @@ -187,6 +197,9 @@ def __init__( pad_to_multiple_of: int, bin_cost: Callable[[Sequence[int]], int], config: TransportConfig, + model_name: str, + model_trust_remote_code: bool, + missing_mm_image_policy: MissingMMImagePolicy = "placeholder_zero_loss", ): self.world = get_world() @@ -205,6 +218,9 @@ def __init__( self.multi_run_manager = get_multi_run_manager() self.receiver: MicroBatchReceiver = setup_micro_batch_receiver(output_dir, dp_rank, start_step, config) + self.mm_materializer = RawImageMaterializer(model_name, trust_remote_code=model_trust_remote_code) + self.missing_mm_image_policy = missing_mm_image_policy + self._reset_mm_stats() def wait_for_batch(self) -> None: if self.world.is_master: @@ -218,22 +234,70 @@ def wait_for_batch(self) -> None: def get_batch(self) -> list[TensorMicroBatch]: micro_batches = self.receiver.receive() + self._reset_mm_stats() return [self._micro_batch_to_tensor(mb) for mb in micro_batches] + def _reset_mm_stats(self) -> None: + self.last_mm_materialize_time = 0.0 + self.last_mm_images_materialized = 0 + self.last_mm_images_placeholdered = 0 + + @staticmethod + def _materialized_mm_parts(materialized: MaterializedMM | None) -> MaterializedMMParts: + if materialized is None: + return None, None + return materialized.kwargs, materialized.forward_policy + + @staticmethod + def _mm_run_context(micro_batch: MicroBatch) -> str: + run_idx = next((i for i, n in enumerate(micro_batch.lora_num_tokens or []) if n > 0), None) + return f"run_idx={run_idx}, run_id={micro_batch.run_id}, run_step={micro_batch.run_step}" + + def _materialize_mm_refs(self, micro_batch: MicroBatch, refs: MMRefs) -> MaterializedMMParts: + materialize_start = time.perf_counter() + try: + materialized = self.mm_materializer.materialize(refs) + except FileNotFoundError as exc: + self.last_mm_materialize_time += time.perf_counter() - materialize_start + if self.missing_mm_image_policy == "error": + get_logger().error( + f"raw image materialization failed ({self._mm_run_context(micro_batch)}, uris={refs.uris}): {exc!r}" + ) + raise + return self._synthesize_missing_mm_placeholder(micro_batch, refs) + + self.last_mm_materialize_time += time.perf_counter() - materialize_start + self.last_mm_images_materialized += len(refs.uris) + return self._materialized_mm_parts(materialized) + + def _synthesize_missing_mm_placeholder(self, micro_batch: MicroBatch, refs: MMRefs) -> MaterializedMMParts: + placeholder_start = time.perf_counter() + materialized = self.mm_materializer.synthesize_placeholder(refs) + self.last_mm_materialize_time += time.perf_counter() - placeholder_start + self.last_mm_images_placeholdered += len(refs.uris) + micro_batch.loss_mask = [False] * len(micro_batch.loss_mask) + micro_batch.advantages = [0.0] * len(micro_batch.advantages) + + missing_uris = missing_file_uris(refs.uris) + get_logger().warning( + "raw image materialization missing image(s); using zero-loss placeholder " + f"({self._mm_run_context(micro_batch)}, " + f"missing_uris={missing_uris or ['']}, " + f"uris={refs.uris})" + ) + return self._materialized_mm_parts(materialized) + def _micro_batch_to_tensor(self, micro_batch: MicroBatch) -> TensorMicroBatch: """Convert a MicroBatch (msgspec struct with lists) to a TensorMicroBatch (dict with tensors).""" if micro_batch.lora_num_tokens is None: micro_batch.lora_num_tokens = [0] * self.multi_run_manager.max_runs micro_batch.lora_num_tokens[0] = len(micro_batch.input_ids) mm_kwargs: dict[str, Tensor] | None = None - if micro_batch.mm_kwargs: - # Each value is an EncodedTensor (dtype, shape, raw bytes). - # No batch dim — the orchestrator concatenates per-image along - # dim=0 generically, matching what each HF VLM's forward expects. - mm_kwargs = { - key: torch.frombuffer(bytearray(payload.data), dtype=_torch_dtype(payload.dtype)).reshape(payload.shape) - for key, payload in micro_batch.mm_kwargs.items() - } + mm_forward_policy: ForwardPolicy | None = None + if micro_batch.mm_kwargs is not None: + raise ValueError("Processed multimodal mm_kwargs are unsupported in v1; use raw mm_refs") + if micro_batch.mm_refs is not None: + mm_kwargs, mm_forward_policy = self._materialize_mm_refs(micro_batch, micro_batch.mm_refs) routed_experts = None packed_routed_experts = micro_batch.routed_experts if packed_routed_experts is not None: @@ -261,6 +325,7 @@ def _micro_batch_to_tensor(self, micro_batch: MicroBatch) -> TensorMicroBatch: lora_num_tokens=torch.tensor(micro_batch.lora_num_tokens, dtype=torch.int32), seq_lens=torch.tensor(micro_batch.seq_lens, dtype=torch.long), mm_kwargs=mm_kwargs, + mm_forward_policy=mm_forward_policy, mm_token_type_ids=torch.tensor(micro_batch.mm_token_type_ids, dtype=torch.long).unsqueeze(0) if micro_batch.mm_token_type_ids is not None else None, diff --git a/src/prime_rl/trainer/rl/train.py b/src/prime_rl/trainer/rl/train.py index 295d3ad15e..4e3497999e 100644 --- a/src/prime_rl/trainer/rl/train.py +++ b/src/prime_rl/trainer/rl/train.py @@ -251,6 +251,9 @@ def load_run_checkpoint(_optimizer, idx: int) -> None: config.model.cp, build_bin_cost(model.config), config.rollout_transport, + config.model.name, + config.model.trust_remote_code, + missing_mm_image_policy=config.missing_mm_image_policy, ) token_exporter = setup_token_exporter(config, parallel_dims, world, logger) @@ -365,12 +368,10 @@ def load_run_checkpoint(_optimizer, idx: int) -> None: # we could've gotten routed experts from the inference server, but we didn't enable router replay routed_experts = None - # Multimodal kwargs are an opaque per-model dict (e.g. - # {"pixel_values": ..., "image_grid_thw": ...} for Qwen3-VL, - # just {"pixel_values": ...} for Gemma3-VL) — we move every - # tensor to CUDA and let the model's forward sort them. + # Multimodal kwargs are materialized by the trainer model processor. mm_kwargs_raw = micro_batch.get("mm_kwargs") mm_kwargs = {k: v.to("cuda") for k, v in mm_kwargs_raw.items()} if mm_kwargs_raw else None + mm_forward_policy = micro_batch.get("mm_forward_policy") if mm_kwargs is not None and config.model.vlm is None: raise ValueError( "Received multimodal samples but [model.vlm] is not set. " @@ -433,6 +434,7 @@ def load_run_checkpoint(_optimizer, idx: int) -> None: labels=labels, temperature=temperatures, mm_kwargs=mm_kwargs, + mm_forward_policy=mm_forward_policy, mm_token_type_ids=mm_token_type_ids, seq_lens=seq_lens, seq_lens_are_pre_shard=seq_lens_are_pre_shard, @@ -717,9 +719,12 @@ def load_run_checkpoint(_optimizer, idx: int) -> None: "time/step": step_time, "time/wait_for_batch": wait_for_batch_time, "time/load_data": load_data_time, + "time/mm_materialize": dataloader.last_mm_materialize_time, "time/broadcast_weights": broadcast_weights_time, "time/save_ckpt": save_ckpt_time, "time/forward_backward": forward_backward_time, + "mm/images_materialized": dataloader.last_mm_images_materialized, + "mm/images_placeholdered": dataloader.last_mm_images_placeholdered, "step": progress.step, } monitor.log(time_metrics, step=progress.step) diff --git a/src/prime_rl/transport/types.py b/src/prime_rl/transport/types.py index 121da68d92..c6d8ed490a 100644 --- a/src/prime_rl/transport/types.py +++ b/src/prime_rl/transport/types.py @@ -18,6 +18,36 @@ class RoutedExperts(msgspec.Struct, array_like=True, gc=False, omit_defaults=Tru dtype: str +class MMImageRef(msgspec.Struct, array_like=True, gc=False, omit_defaults=True): + """One raw image reference for trainer-side materialization. + + ``item`` is the JSON-safe renderer descriptor (adapter family + payload, + parseable via ``parse_raw_mm_item``), ``hash``/``uri`` identify the raw image + file, and ``offset``/``length`` are the image's placeholder range in token + space (needed to truncate at image boundaries). + """ + + item: dict + hash: str + uri: str + offset: int + length: int + + +class MMRefs(msgspec.Struct, array_like=True, gc=False, omit_defaults=True): + """Raw multimodal sidecar references for one sample, in token order. + + The trainer materializes the referenced image files with its own processor. + Processed tensors are intentionally not part of this transport. + """ + + images: list[MMImageRef] + + @property + def uris(self) -> list[str]: + return [image.uri for image in self.images] + + # Orchestrator -> Packer class TrainingSample(msgspec.Struct, array_like=True, gc=False, omit_defaults=True): """A single training example — one branch of a rollout as a flat token sequence. @@ -34,16 +64,11 @@ class TrainingSample(msgspec.Struct, array_like=True, gc=False, omit_defaults=Tr env_name: str ref_logprobs: list[float] | None = None # reference-model logprobs (ref_kl component) - # Generic multimodal kwargs: flat dict keyed by the kwarg names the - # model's forward expects (e.g. {"pixel_values": ..., "image_grid_thw": - # ...} for Qwen3-VL; just {"pixel_values": ...} for Gemma3). The - # orchestrator batches per-image renderer items by torch.cat along - # dim=0 generically — no model-specific knowledge in prime-rl. The - # trainer ``**`` -unpacks this into the model forward, so any VLM - # whose HF processor / forward agree on kwarg names works without - # touching this transport. + # Processed multimodal payloads are rejected by the v1 raw-image-ref path. mm_kwargs: dict[str, EncodedTensor] | None = None + mm_refs: MMRefs | None = None + routed_experts: RoutedExperts | None = None # mm_token_type_ids: token type ids per token [batch seq], int64 (0=text, 1=image, 2=video) @@ -94,8 +119,9 @@ class MicroBatch(msgspec.Struct, array_like=True, gc=False, omit_defaults=True): lora_num_tokens: list[int] | None = None routed_experts: RoutedExperts | None = None - # See TrainingSample.mm_kwargs. + # Processed multimodal payloads are rejected by the v1 raw-image-ref path. mm_kwargs: dict[str, EncodedTensor] | None = None + mm_refs: MMRefs | None = None # mm_token_type_ids: token type ids per token [batch seq], int64 (0=text, 1=image, 2=video) mm_token_type_ids: list[int] | None = None diff --git a/src/prime_rl/utils/mm.py b/src/prime_rl/utils/mm.py new file mode 100644 index 0000000000..cbdcff38c8 --- /dev/null +++ b/src/prime_rl/utils/mm.py @@ -0,0 +1,187 @@ +from __future__ import annotations + +import hashlib +from collections.abc import Iterable, Mapping +from io import BytesIO +from pathlib import Path +from typing import Any +from urllib.parse import unquote, urlparse + +from prime_rl.multimodal.adapters.base import MaterializedMM, MultimodalAdapter +from prime_rl.multimodal.registry import get_multimodal_adapter +from prime_rl.multimodal.schema import RawMMItem, parse_raw_mm_item +from prime_rl.transport.types import MMImageRef, MMRefs + +IMAGE_MODALITY = "image" +SUPPORTED_MODALITIES = {IMAGE_MODALITY} + + +def _field(value: Any, name: str, default: Any = None) -> Any: + if isinstance(value, Mapping): + return value.get(name, default) + return getattr(value, name, default) + + +def file_uri_to_path(uri: str) -> Path: + parsed = urlparse(uri) + if parsed.scheme != "file": + raise ValueError(f"Raw multimodal image refs must be file:// URIs, got {uri!r}") + if parsed.netloc not in ("", "localhost"): + raise ValueError(f"file:// multimodal refs must be local paths, got {uri!r}") + return Path(unquote(parsed.path)) + + +def missing_file_uris(uris: Iterable[str]) -> list[str]: + """Return missing local ``file://`` image refs; non-file refs are ignored.""" + missing: list[str] = [] + for uri in uris: + if urlparse(uri).scheme != "file": + continue + if not file_uri_to_path(uri).exists(): + missing.append(uri) + return missing + + +def _validate_modalities(mm_items: Mapping[str, list[Any]]) -> None: + unsupported = sorted( + modality for modality, items in mm_items.items() if items and modality not in SUPPORTED_MODALITIES + ) + if unsupported: + raise NotImplementedError( + "v1 multimodal training currently supports raw image refs only; " + f"unsupported modalities: {', '.join(unsupported)}" + ) + + +def _raw_item_dicts(items: Iterable[Mapping[str, Any]]) -> tuple[list[dict[str, Any]], list[str]]: + item_dicts: list[dict[str, Any]] = [] + uris: list[str] = [] + for item in items: + item_dict = dict(item) + parsed = parse_raw_mm_item(item_dict) + file_uri_to_path(parsed.raw_image_uri) + item_dicts.append(item_dict) + uris.append(parsed.raw_image_uri) + return item_dicts, uris + + +def _placeholder_bounds(placeholder: Any) -> tuple[int, int]: + offset = _field(placeholder, "offset") + length = _field(placeholder, "length") + if not isinstance(offset, int) or not isinstance(length, int): + raise ValueError(f"Raw image placeholder must have integer offset/length, got {placeholder!r}") + if offset < 0 or length <= 0: + raise ValueError(f"Raw image placeholder must have offset >= 0 and length > 0, got {placeholder!r}") + return offset, length + + +def build_mm_refs(multi_modal_data: Any) -> MMRefs | None: + mm_items = _field(multi_modal_data, "mm_items", None) + if not mm_items: + return None + _validate_modalities(mm_items) + + image_items, uris = _raw_item_dicts(mm_items.get(IMAGE_MODALITY, [])) + if not image_items: + return None + + mm_hashes = _field(multi_modal_data, "mm_hashes", {}) or {} + image_hashes = list(mm_hashes.get(IMAGE_MODALITY, [])) + mm_placeholders = _field(multi_modal_data, "mm_placeholders", {}) or {} + image_placeholders = list(mm_placeholders.get(IMAGE_MODALITY, [])) + if len(image_hashes) != len(image_items) or len(image_placeholders) != len(image_items): + raise ValueError( + "Raw image descriptor/hash/placeholder mismatch: " + f"descriptors={len(image_items)}, hashes={len(image_hashes)}, placeholders={len(image_placeholders)}" + ) + + images: list[MMImageRef] = [] + prev_end = 0 + for item, uri, image_hash, placeholder in zip(image_items, uris, image_hashes, image_placeholders, strict=True): + offset, length = _placeholder_bounds(placeholder) + # Truncation cuts at a prefix of ``images``, which is only sound if + # placeholders arrive in token order without overlap. + if offset < prev_end: + raise ValueError(f"Raw image placeholders must be sorted and non-overlapping, got {image_placeholders!r}") + prev_end = offset + length + images.append(MMImageRef(item=item, hash=image_hash, uri=uri, offset=offset, length=length)) + return MMRefs(images=images) + + +def sha256_32(data: bytes) -> str: + return hashlib.sha256(data).hexdigest()[:32] + + +def _parse_image_refs(refs: MMRefs) -> list[RawMMItem]: + return [parse_raw_mm_item(image.item) for image in refs.images] + + +def _single_family_adapter(items: list[RawMMItem]) -> MultimodalAdapter: + families = {item.family for item in items} + if len(families) != 1: + raise ValueError(f"Raw multimodal refs must use exactly one adapter family, got {sorted(families)}") + return get_multimodal_adapter(next(iter(families))) + + +def _validate_processor_layout(adapter: MultimodalAdapter, image_processor: Any, image_items: list[RawMMItem]) -> None: + actual_fingerprint = adapter.processor_fingerprint(image_processor) + for item in image_items: + if item.layout_fingerprint != actual_fingerprint: + raise ValueError( + f"Raw image layout fingerprint mismatch: expected {item.layout_fingerprint}, got {actual_fingerprint}" + ) + + +def _load_verified_images(image_refs: list[MMImageRef]) -> list[Any]: + from PIL import Image + + images = [] + for ref in image_refs: + raw = file_uri_to_path(ref.uri).read_bytes() + actual_hash = sha256_32(raw) + if actual_hash != ref.hash: + raise ValueError(f"Raw image hash mismatch for {ref.uri}: expected {ref.hash}, got {actual_hash}") + with Image.open(BytesIO(raw)) as image: + images.append(image.convert("RGB")) + return images + + +class RawImageMaterializer: + """Materialize raw image refs with the trainer model's HF image processor.""" + + def __init__(self, model_name: str, *, trust_remote_code: bool): + self.model_name = model_name + self.trust_remote_code = trust_remote_code + self._image_processor = None + + @property + def image_processor(self): + if self._image_processor is None: + from transformers import AutoProcessor + + processor = AutoProcessor.from_pretrained(self.model_name, trust_remote_code=self.trust_remote_code) + image_processor = getattr(processor, "image_processor", None) + if image_processor is None: + raise ValueError(f"{self.model_name!r} does not expose an image_processor") + self._image_processor = image_processor + return self._image_processor + + def materialize(self, refs: MMRefs) -> MaterializedMM | None: + image_items = _parse_image_refs(refs) + if not image_items: + return None + + image_processor = self.image_processor + adapter = _single_family_adapter(image_items) + _validate_processor_layout(adapter, image_processor, image_items) + images = _load_verified_images(refs.images) + return adapter.materialize_for_trainer(image_processor, image_items, images) + + def synthesize_placeholder(self, refs: MMRefs) -> MaterializedMM | None: + """Build zero-valued multimodal tensors via the owning adapter.""" + image_items = _parse_image_refs(refs) + if not image_items: + return None + image_processor = self.image_processor + adapter = _single_family_adapter(image_items) + return adapter.synthesize_placeholder(image_processor, image_items) diff --git a/src/prime_rl/utils/run_assets.py b/src/prime_rl/utils/run_assets.py new file mode 100644 index 0000000000..a359e45ec7 --- /dev/null +++ b/src/prime_rl/utils/run_assets.py @@ -0,0 +1,68 @@ +from __future__ import annotations + +import os +from collections.abc import Mapping +from pathlib import Path +from string import Template + +from prime_rl.configs.shared import MultimodalConfig + +# Contract: must match renderers.mm_store.IMAGE_OFFLOAD_DIR_ENV. +IMAGE_OFFLOAD_DIR_ENV = "VF_RENDERER_IMAGE_OFFLOAD_DIR" +RUN_ID_ENV = "RUN_ID" + +RUN_OUTPUT_ROOT = Path("/data/outputs") +IMAGE_ASSET_SUBDIR = Path("assets/images") + + +def _expand_path(path: Path, env: Mapping[str, str]) -> Path: + expanded = Template(os.path.expanduser(str(path))).safe_substitute(env) + return Path(expanded).resolve() + + +def _run_id_dir(env: Mapping[str, str]) -> Path | None: + raw_run_id = env.get(RUN_ID_ENV, "").strip() + if not raw_run_id: + return None + run_id = raw_run_id.removeprefix("run_") + return RUN_OUTPUT_ROOT / f"run_{run_id}" + + +def resolve_image_offload_dir( + output_dir: Path, + multimodal: MultimodalConfig, + env: Mapping[str, str], +) -> Path: + """Resolve image asset dir by precedence: offload_dir, RUN_ID hosted path, then output_dir/assets/images.""" + explicit = multimodal.offload_dir + if explicit is not None: + return _expand_path(explicit, env) + hosted_run_dir = _run_id_dir(env) + if hosted_run_dir is not None: + return (hosted_run_dir / IMAGE_ASSET_SUBDIR).resolve() + return (output_dir.resolve() / IMAGE_ASSET_SUBDIR).resolve() + + +def build_run_asset_env( + output_dir: Path, + multimodal: MultimodalConfig | None = None, + base: Mapping[str, str] | None = None, +) -> dict[str, str]: + """Resolve the environment used by subprocesses that share run image assets. + + Prime-RL config owns the multimodal image offload path. Env vars are only the + transport used by verifiers/renderers running in subprocesses. + """ + + env = dict(os.environ if base is None else base) + config = multimodal or MultimodalConfig() + + env[IMAGE_OFFLOAD_DIR_ENV] = str(resolve_image_offload_dir(output_dir, config, env)) + + return env + + +def apply_run_asset_env(output_dir: Path, multimodal: MultimodalConfig) -> None: + if os.environ.get(IMAGE_OFFLOAD_DIR_ENV): + return + os.environ.update(build_run_asset_env(output_dir, multimodal=multimodal)) diff --git a/tests/unit/inference/test_serving_tokens.py b/tests/unit/inference/test_serving_tokens.py index 951ef5c9d8..80be7c3099 100644 --- a/tests/unit/inference/test_serving_tokens.py +++ b/tests/unit/inference/test_serving_tokens.py @@ -11,6 +11,7 @@ from __future__ import annotations import asyncio +import hashlib import numpy as np import pybase64 @@ -267,3 +268,261 @@ def test_client_set_max_tokens_assumes_set_when_body_unreadable(): # non-dict body → can't tell, don't override. assert asyncio.run(_client_set_max_tokens(_FakeRawRequest([1, 2, 3]))) is True + + +def test_materialize_raw_image_ref_uses_generic_family_payload(tmp_path, monkeypatch): + from PIL import Image + from renderers.mm_store import raw_mm_ref + + from prime_rl.inference.vllm import serving_tokens + + image_dir = tmp_path / "run_serving" / "assets" / "images" + image_dir.mkdir(parents=True) + image_path = image_dir / "image.png" + Image.new("RGB", (8, 6), color=(32, 64, 128)).save(image_path) + + mm_hash = hashlib.sha256(image_path.read_bytes()).hexdigest()[:32] + fingerprint = "f" * 32 + raw_ref = raw_mm_ref( + family="test_family", + fingerprint=fingerprint, + modality="image", + mm_hash=mm_hash, + raw_image_uri=image_path.as_uri(), + payload={"adapter_owned": [1, 2, 3]}, + ) + processor = object() + captured = {} + + class _Adapter: + def materialize_for_vllm(self, image_processor, item, image, expected_placeholder_length): + captured["image_processor"] = image_processor + captured["item"] = item + captured["image_size"] = image.size + captured["expected_placeholder_length"] = expected_placeholder_length + return {"materialized": True} + + def _get_adapter(family): + captured["family"] = family + return _Adapter() + + monkeypatch.setattr(serving_tokens, "_load_image_processor", lambda _model, _trust: processor) + monkeypatch.setattr(serving_tokens, "get_multimodal_adapter", _get_adapter) + + out = serving_tokens._materialize_raw_image_ref_sync( + raw_ref, + feature_modality="image", + mm_hash=mm_hash, + expected_placeholder_length=7, + processor_model_name="model", + trust_remote_code=True, + ) + + assert out == {"materialized": True} + assert captured["family"] == "test_family" + assert captured["image_processor"] is processor + assert captured["image_size"] == (8, 6) + assert captured["expected_placeholder_length"] == 7 + item = captured["item"] + assert item.family == "test_family" + assert item.layout_fingerprint == fingerprint + assert item.raw_image_uri == image_path.as_uri() + assert item.payload == {"adapter_owned": [1, 2, 3]} + + +def test_materialize_raw_image_ref_maps_adapter_validation_error(tmp_path, monkeypatch): + import pytest + + from prime_rl.inference.vllm import serving_tokens + + features = _mm_features(tmp_path) + raw_ref = features.kwargs_data["image"][0] + mm_hash = features.mm_hashes["image"][0] + + class _InvalidAdapter: + def materialize_for_vllm(self, image_processor, item, image, expected_placeholder_length): + raise ValueError("image layout fingerprint mismatch") + + monkeypatch.setattr(serving_tokens, "_load_image_processor", lambda _model, _trust: object()) + monkeypatch.setattr(serving_tokens, "get_multimodal_adapter", lambda _family: _InvalidAdapter()) + + with pytest.raises(serving_tokens._MMImageRefError, match="image layout fingerprint mismatch") as exc_info: + serving_tokens._materialize_raw_image_ref_sync( + raw_ref, + feature_modality="image", + mm_hash=mm_hash, + expected_placeholder_length=7, + processor_model_name="model", + trust_remote_code=False, + ) + + assert exc_info.value.status_code == 400 + + +def _mm_features(tmp_path, *, image_seed: int = 0, placeholder_length: int = 7): + """A minimal ``GenerateRequest.features``-shaped object carrying one real raw ref.""" + from types import SimpleNamespace + + from PIL import Image + from renderers.mm_store import raw_mm_ref + + image_dir = tmp_path / "assets" / "images" + image_dir.mkdir(parents=True, exist_ok=True) + image_path = image_dir / f"image-{image_seed}.png" + Image.new("RGB", (8, 6), color=(image_seed % 255, 64, 128)).save(image_path) + + mm_hash = hashlib.sha256(image_path.read_bytes()).hexdigest()[:32] + raw_ref = raw_mm_ref( + family="test_family", + fingerprint="f" * 32, + modality="image", + mm_hash=mm_hash, + raw_image_uri=image_path.as_uri(), + payload={}, + ) + return SimpleNamespace( + mm_hashes={"image": [mm_hash]}, + kwargs_data={"image": [raw_ref]}, + mm_placeholders={"image": [SimpleNamespace(offset=0, length=placeholder_length)]}, + ) + + +def _patch_adapter(monkeypatch, calls: list, materialize=None): + from prime_rl.inference.vllm import serving_tokens + + class _Adapter: + def materialize_for_vllm(self, image_processor, item, image, expected_placeholder_length): + calls.append(item.raw_ref) + if materialize is not None: + return materialize(item) + return {"materialized": item.raw_image_uri} + + monkeypatch.setattr(serving_tokens, "_load_image_processor", lambda _model, _trust: object()) + monkeypatch.setattr(serving_tokens, "get_multimodal_adapter", lambda _family: _Adapter()) + + +def test_mm_materialize_cache_hit_skips_work(tmp_path, monkeypatch): + from prime_rl.inference.vllm import serving_tokens + + calls: list = [] + _patch_adapter(monkeypatch, calls) + cache = serving_tokens._MaterializedRefCache(max_bytes=1 << 20) + features = _mm_features(tmp_path) + + async def _run(): + first = await serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ) + second = await serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ) + return first, second + + first, second = asyncio.run(_run()) + assert len(calls) == 1 + assert first["image"][0] is second["image"][0] + assert (cache.hits, cache.misses) == (1, 1) + + +def test_mm_materialize_cache_does_not_alias_distinct_raw_refs(tmp_path, monkeypatch): + import pytest + + from prime_rl.inference.vllm import serving_tokens + + calls: list = [] + _patch_adapter(monkeypatch, calls) + cache = serving_tokens._MaterializedRefCache(max_bytes=1 << 20) + valid = _mm_features(tmp_path, image_seed=1) + forged = _mm_features(tmp_path, image_seed=2) + forged.mm_hashes["image"][0] = valid.mm_hashes["image"][0] + + async def _run(): + await serving_tokens._decode_raw_mm_kwargs( + valid, processor_model_name="model", trust_remote_code=False, cache=cache + ) + await serving_tokens._decode_raw_mm_kwargs( + forged, processor_model_name="model", trust_remote_code=False, cache=cache + ) + + with pytest.raises(serving_tokens._MMImageRefError, match="Expected image hash"): + asyncio.run(_run()) + assert len(calls) == 1 + assert (cache.hits, cache.misses) == (0, 2) + + +def test_mm_materialize_cache_byte_budget_evicts_oldest(tmp_path, monkeypatch): + from vllm.multimodal.cache import MultiModalCache + + from prime_rl.inference.vllm import serving_tokens + + calls: list = [] + _patch_adapter(monkeypatch, calls) + monkeypatch.setattr(MultiModalCache, "get_item_size", classmethod(lambda _cls, _item: 60)) + cache = serving_tokens._MaterializedRefCache(max_bytes=100) + features_a = _mm_features(tmp_path, image_seed=1) + features_b = _mm_features(tmp_path, image_seed=2) + + async def _decode(features): + return await serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ) + + asyncio.run(_decode(features_a)) + asyncio.run(_decode(features_b)) # 60 + 60 > 100: evicts a + assert cache.evictions == 1 + asyncio.run(_decode(features_a)) # miss again: re-materializes + assert len(calls) == 3 + assert cache.misses == 3 + + +def test_mm_materialize_cache_failure_not_cached(tmp_path, monkeypatch): + import pytest + + from prime_rl.inference.vllm import serving_tokens + + calls: list = [] + fail_first = {"remaining": 1} + + def _materialize(item): + if fail_first["remaining"]: + fail_first["remaining"] -= 1 + raise serving_tokens._MMImageRefError("transient failure") + return {"materialized": True} + + _patch_adapter(monkeypatch, calls, materialize=_materialize) + cache = serving_tokens._MaterializedRefCache(max_bytes=1 << 20) + features = _mm_features(tmp_path) + + async def _decode(): + return await serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ) + + with pytest.raises(serving_tokens._MMImageRefError): + asyncio.run(_decode()) + out = asyncio.run(_decode()) + assert out["image"][0] == {"materialized": True} + assert len(calls) == 2 + + +def test_mm_materialize_cache_single_flight(tmp_path, monkeypatch): + from prime_rl.inference.vllm import serving_tokens + + calls: list = [] + _patch_adapter(monkeypatch, calls) + cache = serving_tokens._MaterializedRefCache(max_bytes=1 << 20) + features = _mm_features(tmp_path) + + async def _run(): + return await asyncio.gather( + serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ), + serving_tokens._decode_raw_mm_kwargs( + features, processor_model_name="model", trust_remote_code=False, cache=cache + ), + ) + + first, second = asyncio.run(_run()) + assert len(calls) == 1 + assert first["image"][0] is second["image"][0] diff --git a/tests/unit/orchestrator/test_batch.py b/tests/unit/orchestrator/test_batch.py index 8b4b31f7ed..5b0236596d 100644 --- a/tests/unit/orchestrator/test_batch.py +++ b/tests/unit/orchestrator/test_batch.py @@ -5,7 +5,7 @@ from prime_rl.trainer.batch import pad_micro_batch, prepare_batch, prepare_sample from prime_rl.trainer.utils import build_bin_cost -from prime_rl.transport.types import EncodedTensor, MicroBatch, RoutedExperts, TrainingSample +from prime_rl.transport.types import MicroBatch, MMImageRef, MMRefs, RoutedExperts, TrainingSample def _routed_experts(data, dtype=np.uint8): @@ -17,11 +17,6 @@ def _routed_experts(data, dtype=np.uint8): ) -def _encoded(arr) -> EncodedTensor: - a = np.asarray(arr) - return EncodedTensor(data=a.tobytes(), shape=list(a.shape), dtype=str(a.dtype)) - - @pytest.fixture def make_training_example(): def _make_training_example( @@ -416,52 +411,69 @@ def test_prepare_sample_truncates_routed_experts(): assert micro_batch.env_names == ["test-env"] * 3 -def test_prepare_sample_truncates_mm_at_image_boundary(): - """Truncation never splits an image's placeholder block: it cuts to a whole-image boundary - and slices mm_kwargs to match, so image-token count stays == image-embedding count.""" - # Two 2-token images (patches-per-token = 1): image-pad at indices 1,2 (img0) and 4,5 (img1). - mm_token_type_ids = [0, 1, 1, 0, 1, 1, 0] - pixel_values = np.array([[1.0], [1.0], [2.0], [2.0]], dtype=np.float32) # img0=1.0, img1=2.0 - grid = np.array([[1, 2, 1], [1, 2, 1]], dtype=np.int64) +def _image_ref(uri: str, offset: int, length: int) -> MMImageRef: + return MMImageRef( + item={ + "kind": "prime_raw_mm_item", + "modality": "image", + "family": "qwen_vl", + "layout_fingerprint": "f" * 32, + "raw_image_uri": uri, + "payload": {"image_grid_thw": [[1, 1, 1]]}, + }, + hash="a" * 32, + uri=uri, + offset=offset, + length=length, + ) + + +def test_prepare_sample_truncates_raw_mm_refs_at_image_boundary(): + first_image = _image_ref("file:///tmp/image-0.png", offset=1, length=2) + second_image = _image_ref("file:///tmp/image-1.png", offset=4, length=2) sample = TrainingSample( token_ids=[10, 11, 12, 13, 14, 15, 16], - mask=[False, False, False, False, False, True, True], + mask=[False, False, True, True, False, True, True], logprobs=[0.0] * 7, temperatures=[1.0] * 7, - advantages=[0.0] * 6 + [1.0], + advantages=[0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0], env_name="test-env", - mm_token_type_ids=mm_token_type_ids, - mm_kwargs={"pixel_values": _encoded(pixel_values), "image_grid_thw": _encoded(grid)}, + mm_token_type_ids=[0, 1, 1, 0, 1, 1, 0], + mm_refs=MMRefs(images=[first_image, second_image]), ) - # seq_len=5 falls inside img1 (one of its two placeholders survives) -> drop img1 entirely. - mb = prepare_sample(sample, seq_len=5) - assert len(mb.input_ids) == 4 # cut back to img1's first placeholder (index 4) - assert len(mb.mm_token_type_ids) == len(mb.input_ids) - n_placeholders = sum(1 for t in mb.mm_token_type_ids if t) - assert n_placeholders == 2 # only img0's two placeholders remain - # No mismatch: placeholders == image embeddings, and only img0's pixels are kept. - assert mb.mm_kwargs["pixel_values"].shape == [2, 1] - assert mb.mm_kwargs["image_grid_thw"].shape == [1, 3] - kept = np.frombuffer(bytearray(mb.mm_kwargs["pixel_values"].data), dtype=np.float32) - assert kept.tolist() == [1.0, 1.0] - assert n_placeholders == mb.mm_kwargs["pixel_values"].shape[0] # ppt == 1 here - - -def test_prepare_batch_packs_multimodal_with_text(): - mm_sample = TrainingSample( - token_ids=[10, 11, 12], - mask=[False, True, True], - logprobs=[0.0, -0.1, -0.2], - temperatures=[1.0, 1.0, 1.0], - advantages=[0.0, 1.0, 1.0], - env_name="mm-env", - mm_token_type_ids=[0, 1, 0], - mm_kwargs={ - "pixel_values": _encoded(np.array([[1.0, 2.0]], dtype=np.float32)), - "image_grid_thw": _encoded(np.array([[1, 2, 2]], dtype=np.int64)), - }, - ) + # seq_len=5 splits the second image: cut at its start, keep refs for the first. + micro_batch = prepare_sample(sample, seq_len=5) + assert micro_batch.input_ids == [10, 11, 12, 13] + assert micro_batch.mm_token_type_ids == [0, 1, 1, 0] + assert micro_batch.mm_refs == MMRefs(images=[first_image]) + + # seq_len=2 splits the first image: no image survives. + micro_batch = prepare_sample(sample, seq_len=2) + assert micro_batch.input_ids == [10] + assert micro_batch.mm_token_type_ids == [0] + assert micro_batch.mm_refs is None + + +def test_prepare_batch_packs_raw_mm_samples_with_rebased_offsets(): + """Same-family raw-ref samples pack with each other and with text from the same + run/LoRA; merged image ref offsets are rebased to the packed token stream. A + different adapter family never joins the bin.""" + + def mm_sample(uri: str, family: str = "qwen_vl") -> TrainingSample: + ref = _image_ref(uri, offset=1, length=1) + ref.item["family"] = family + return TrainingSample( + token_ids=[10, 11, 12], + mask=[False, True, True], + logprobs=[0.0, -0.1, -0.2], + temperatures=[1.0, 1.0, 1.0], + advantages=[0.0, 1.0, 1.0], + env_name="mm-env", + mm_token_type_ids=[0, 1, 0], + mm_refs=MMRefs(images=[ref]), + ) + text_sample = TrainingSample( token_ids=[20, 21], mask=[False, True], @@ -472,25 +484,33 @@ def test_prepare_batch_packs_multimodal_with_text(): ) batches_per_gpu = prepare_batch( - rollouts=[mm_sample, text_sample], - seq_len=8, + rollouts=[ + mm_sample("file:///tmp/image-0.png"), + mm_sample("file:///tmp/image-1.png"), + mm_sample("file:///tmp/image-2.png", family="kimi_k25"), + text_sample, + ], + seq_len=16, num_train_workers=2, - idxs=[0, 0], + idxs=[0, 0, 0, 0], num_loras=1, bin_cost=build_bin_cost(None), ) real_batches = [batch for batch in _flatten_batches(batches_per_gpu) if _has_loss_tokens(batch)] - assert len(real_batches) == 1 - batch = real_batches[0] - assert batch.seq_lens == [3, 2] - assert batch.sequence_lengths == [3, 2] - assert batch.position_ids == [0, 1, 2, 0, 1] - assert batch.mm_token_type_ids == [0, 1, 0, 0, 0] - assert batch.mm_kwargs is not None - assert batch.mm_kwargs["pixel_values"].shape == [1, 2] - assert batch.mm_kwargs["image_grid_thw"].shape == [1, 3] - assert batch.env_names == ["mm-env"] * 3 + ["text-env"] * 2 + mm_batches = [batch for batch in real_batches if batch.mm_refs is not None] + assert len(mm_batches) == 2 + packed = max(mm_batches, key=lambda batch: len(batch.mm_refs.images)) + assert len(packed.mm_refs.images) == 2 + assert packed.seq_lens[:2] == [3, 3] + # Sample-relative offset 1, rebased by each sample's start in the packed stream. + assert [image.offset for image in packed.mm_refs.images] == [1, 4] + assert packed.mm_token_type_ids[:6] == [0, 1, 0, 0, 1, 0] + assert packed.env_names[:6] == ["mm-env"] * 6 + # The kimi-family sample stayed out of the qwen bin. + (other,) = [batch for batch in mm_batches if batch is not packed] + assert len(other.mm_refs.images) == 1 + assert other.mm_refs.images[0].item["family"] == "kimi_k25" def test_prepare_sample_none_routed_experts(): diff --git a/tests/unit/orchestrator/test_metrics.py b/tests/unit/orchestrator/test_metrics.py index 5362037833..2e2cc26d8d 100644 --- a/tests/unit/orchestrator/test_metrics.py +++ b/tests/unit/orchestrator/test_metrics.py @@ -59,7 +59,7 @@ def mk( filter_results=filter_results or {}, timing=SimpleNamespace( setup=SimpleNamespace(duration=setup), - generation=SimpleNamespace( + agent=SimpleNamespace( duration=generation, model=SimpleNamespace(duration=generation_model), harness=SimpleNamespace(duration=generation_harness), diff --git a/tests/unit/orchestrator/test_qwen3_vl_e2e.py b/tests/unit/orchestrator/test_qwen3_vl_e2e.py deleted file mode 100644 index d125e8a469..0000000000 --- a/tests/unit/orchestrator/test_qwen3_vl_e2e.py +++ /dev/null @@ -1,190 +0,0 @@ -"""End-to-end integration test for the Qwen3-VL renderer path. - -Walks a multimodal request through the full client stack — RendererClient -→ renderers.client.generate → /inference/v1/generate features payload — -with the HTTP layer mocked, and verifies that vLLM can deserialize the -features back into engine inputs identical to what its own server-side -processor would have produced for the same messages. - -This is the strongest end-to-end check we can run without a GPU. The -remaining missing piece (vLLM actually consuming the engine input, -sampling tokens, and returning them) is exercised in real rollouts. -""" - -from __future__ import annotations - -import asyncio -import json -from pathlib import Path -from typing import Any -from unittest.mock import MagicMock - -import httpx -import pytest - -_HF_CACHE = Path("~/.cache/huggingface/hub").expanduser() -_MODEL = "Qwen/Qwen3-VL-4B-Instruct" - - -def _model_cached() -> bool: - safe = "models--" + _MODEL.replace("/", "--") - snapshots = _HF_CACHE / safe / "snapshots" - if not snapshots.is_dir(): - return False - return any(p.is_dir() for p in snapshots.iterdir()) - - -pytestmark = pytest.mark.skipif( - not _model_cached(), - reason=f"{_MODEL}: HF snapshot not cached locally", -) - - -class _FakeOpenAI: - """Minimal AsyncOpenAI stand-in that captures POST bodies. - - The renderer client calls ``client.post(absolute_url, body=...)``; - we capture the body for assertions and return a canned generate - response so the parse-side of the flow runs. - """ - - def __init__(self): - self.calls: list[dict[str, Any]] = [] - self.base_url = "http://fake-host:8000/v1" - - async def post(self, path, *, cast_to=dict, body=None, options=None): - self.calls.append({"path": path, "body": body, "options": options}) - # Reply with two sampled tokens + <|im_end|>. The renderer's - # parse_response slices the content tokens. - payload = { - "request_id": "qwen-vl-e2e", - "choices": [ - { - "index": 0, - "token_ids": [50, 60, 151645], - "logprobs": { - "content": [ - {"token": "t1", "logprob": -0.1}, - {"token": "t2", "logprob": -0.2}, - {"token": "t3", "logprob": -0.3}, - ] - }, - "finish_reason": "stop", - }, - ], - } - return httpx.Response(200, content=json.dumps(payload).encode()) - - -def test_renderer_client_qwen3_vl_e2e_features_payload_roundtrips_through_vllm(): - """Walk a Qwen3-VL multimodal turn through the renderer client and - verify the resulting ``/inference/v1/generate`` body has a valid - ``features`` payload that: - - 1. parses through vLLM's ``GenerateRequest`` pydantic model, - 2. decodes back to ``MultiModalKwargsItem`` instances carrying - ``pixel_values`` + ``image_grid_thw`` of the right shapes, - 3. has placeholder ranges that exactly cover the ``<|image_pad|>`` - runs in the prompt token sequence. - """ - from PIL import Image - from renderers.base import load_tokenizer - from renderers.qwen3_vl import Qwen3VLRenderer - from transformers import AutoProcessor - from verifiers.clients.renderer_client import RendererClient - from verifiers.types import ( - ClientConfig, - UserMessage, - ) - from vllm.entrypoints.scale_out.token_in_token_out.mm_serde import decode_mm_kwargs_item - from vllm.entrypoints.scale_out.token_in_token_out.protocol import GenerateRequest - - # ── Build a real Qwen3VLRenderer with a real processor. ───────────── - tokenizer = load_tokenizer(_MODEL) - processor = AutoProcessor.from_pretrained(_MODEL) - renderer = Qwen3VLRenderer(tokenizer, processor=processor) - - image_pad_id = tokenizer.convert_tokens_to_ids("<|image_pad|>") - - # ── Manually wire a RendererClient bypassing the pool factory. ────── - client_cfg = ClientConfig(client_type="renderer", base_url="http://fake-host:8000/v1") - rc = object.__new__(RendererClient) - rc._config = client_cfg - rc._renderer = renderer - rc._pool_size = 1 - rc._client = _FakeOpenAI() - rc.logger = MagicMock() - - # ── Build a verifiers-shaped user message with an image. ──────────── - img = Image.new("RGB", (224, 224), color=(64, 128, 255)) - # The renderer accepts the OpenAI ``image_url`` content-part shape — - # the same shape verifiers' UserMessage carries through. - user = UserMessage( - content=[ - {"type": "text", "text": "What's in this picture?"}, - # Embed the PIL image directly. The verifiers→renderer message - # converter forwards content unchanged for our purposes. - {"type": "image", "image": img}, - ] - ) - - # to_native_prompt converts to renderer-shaped messages. - prompt, _ = asyncio.run(rc.to_native_prompt([user])) - sampling = {"max_tokens": 16} - - response = asyncio.run( - rc.get_native_response( - prompt=prompt, - model=_MODEL, - sampling_args=sampling, - tools=None, - ) - ) - - # ── The HTTP body should carry a features payload. ────────────────── - fake = rc.client - assert isinstance(fake, _FakeOpenAI) - assert len(fake.calls) == 1 - body = fake.calls[0]["body"] - assert "features" in body, "RendererClient should ship features for image content" - features = body["features"] - - # ── Pydantic-roundtrip through vLLM's GenerateRequest model. ──────── - gen_req = GenerateRequest( - token_ids=body["token_ids"], - features=features, - sampling_params=body["sampling_params"], - ) - assert gen_req.features is not None - assert "image" in gen_req.features.mm_hashes - assert len(gen_req.features.mm_hashes["image"]) == 1 - - # ── Placeholder anchoring: the offset/length in features must land - # exactly on a run of <|image_pad|> ids in the prompt. ─────────── - placeholders = gen_req.features.mm_placeholders["image"] - assert len(placeholders) == 1 - ph = placeholders[0] - pad_slice = body["token_ids"][ph.offset : ph.offset + ph.length] - assert all(t == image_pad_id for t in pad_slice), ( - f"placeholder span ({ph.offset}, {ph.length}) does not cover image_pad tokens; slice={pad_slice[:8]}..." - ) - - # ── kwargs_data decodes to MultiModalKwargsItem with the right keys. ─ - assert gen_req.features.kwargs_data is not None - encoded_items = gen_req.features.kwargs_data["image"] - assert len(encoded_items) == 1 - item = decode_mm_kwargs_item(encoded_items[0]) - assert set(item.keys()) == {"pixel_values", "image_grid_thw"} - - # The image_grid_thw must match what the HF processor would have - # produced for the same PIL image — strongest signal that the engine - # sees the same image features the trainer will. - direct_proc_out = processor.image_processor(images=[img], return_tensors="pt") - expected_grid = direct_proc_out["image_grid_thw"][0].tolist() - assert item["image_grid_thw"].data.tolist() == expected_grid - - # ── Response parsed through renderer's parse_response. ────────────── - assert response["completion_ids"] == [50, 60, 151645] - # multi_modal_data surfaces on the result so the caller can persist it. - assert response["multi_modal_data"] is not None - assert len(response["multi_modal_data"].mm_items["image"]) == 1 diff --git a/tests/unit/train/rl/test_packer.py b/tests/unit/train/rl/test_packer.py index 93a1f04355..eab4ac31ab 100644 --- a/tests/unit/train/rl/test_packer.py +++ b/tests/unit/train/rl/test_packer.py @@ -1,7 +1,6 @@ from pathlib import Path from typing import Generator -import numpy as np import pytest import tomli_w import torch @@ -13,7 +12,7 @@ from prime_rl.trainer.runs import setup_multi_run_manager from prime_rl.trainer.utils import build_bin_cost from prime_rl.trainer.world import reset_world -from prime_rl.transport.types import EncodedTensor, TrainingSample +from prime_rl.transport.types import MMImageRef, MMRefs, TrainingSample @pytest.fixture(autouse=True, scope="module") @@ -52,16 +51,8 @@ def make_training_sample() -> TrainingSample: ) -def _encoded_tensor(data, dtype) -> EncodedTensor: - arr = np.asarray(data, dtype=dtype) - return EncodedTensor(dtype=str(arr.dtype), shape=list(arr.shape), data=arr.tobytes()) - - -def _decode_encoded_tensor(encoded: EncodedTensor): - return np.frombuffer(encoded.data, dtype=np.dtype(encoded.dtype)).reshape(encoded.shape).tolist() - - def _mm_sample(value: float, env_name: str = "test-env") -> TrainingSample: + uri = f"file:///tmp/image-{value}.png" return TrainingSample( token_ids=[1, 250, 2], mask=[False, True, True], @@ -70,10 +61,24 @@ def _mm_sample(value: float, env_name: str = "test-env") -> TrainingSample: env_name=env_name, advantages=[0.0, 1.0, 1.0], mm_token_type_ids=[0, 1, 0], - mm_kwargs={ - "pixel_values": _encoded_tensor([[value, value + 1]], np.float32), - "image_grid_thw": _encoded_tensor([[1, 2, 2]], np.int64), - }, + mm_refs=MMRefs( + images=[ + MMImageRef( + item={ + "kind": "prime_raw_mm_item", + "modality": "image", + "family": "qwen_vl", + "layout_fingerprint": "f" * 32, + "raw_image_uri": uri, + "payload": {"image_grid_thw": [[1, 1, 1]]}, + }, + hash="a" * 32, + uri=uri, + offset=1, + length=1, + ) + ] + ), ) @@ -176,7 +181,7 @@ def fake_sender(_output_dir, _data_world_size, _current_step, _config): assert micro_batch.run_step == 1 -def test_multipacker_pack_preserves_mm_kwargs_modality_and_run_tagging(tmp_path, monkeypatch): +def test_multipacker_pack_preserves_mm_modality_alignment_and_run_tagging(tmp_path, monkeypatch): """MultiPacker keeps multimodal and text microbatches aligned across ranks.""" from prime_rl.trainer.batch import _is_multimodal_sample @@ -204,7 +209,7 @@ def test_multipacker_pack_preserves_mm_kwargs_modality_and_run_tagging(tmp_path, assert mm_mbs, "no MM microbatches produced" real_run_idxs = set() for mb in mm_mbs: - assert mb.mm_kwargs is not None + assert mb.mm_refs is not None if any(mb.loss_mask): tagged = [i for i, n in enumerate(mb.lora_num_tokens) if n > 0] assert len(tagged) == 1 and mb.lora_num_tokens[tagged[0]] == len(mb.input_ids) @@ -212,8 +217,8 @@ def test_multipacker_pack_preserves_mm_kwargs_modality_and_run_tagging(tmp_path, assert real_run_idxs == {a, b}, f"both runs' MM should be tagged; got {real_run_idxs}" -def test_multipacker_packs_mm_kwargs_within_each_run(tmp_path, monkeypatch): - """Compatible eager multimodal samples pack within a run but never across runs.""" +def test_multipacker_packs_raw_mm_samples_within_each_run(tmp_path, monkeypatch): + """Same-family raw-ref samples pack within a run (offsets rebased) but never across runs.""" from prime_rl.trainer.batch import _is_multimodal_sample manager, packer, sent = _packer_with_two_runs(tmp_path, monkeypatch, dp_world_size=1, seq_len=12) @@ -230,11 +235,8 @@ def test_multipacker_packs_mm_kwargs_within_each_run(tmp_path, monkeypatch): assert len(real_mm_mbs) == 2 for mb in real_mm_mbs: assert len(mb.input_ids) == 6 - assert mb.position_ids == [0, 1, 2, 0, 1, 2] assert mb.seq_lens == [3, 3] - assert mb.mm_kwargs is not None - assert mb.mm_kwargs["pixel_values"].shape == [2, 2] - assert mb.mm_kwargs["image_grid_thw"].shape == [2, 3] - assert len(_decode_encoded_tensor(mb.mm_kwargs["pixel_values"])) == 2 + assert mb.mm_refs is not None and len(mb.mm_refs.images) == 2 + assert [image.offset for image in mb.mm_refs.images] == [1, 4] tagged = [i for i, n in enumerate(mb.lora_num_tokens) if n > 0] - assert len(tagged) == 1 + assert len(tagged) == 1 and mb.lora_num_tokens[tagged[0]] == 6 diff --git a/tests/unit/train/test_model_forward.py b/tests/unit/train/test_model_forward.py index 14fd521d5e..8071809655 100644 --- a/tests/unit/train/test_model_forward.py +++ b/tests/unit/train/test_model_forward.py @@ -1,8 +1,10 @@ from types import SimpleNamespace +import pytest import torch import torch.nn as nn +from prime_rl.multimodal.adapters.base import ForwardPolicy from prime_rl.trainer.model import forward @@ -35,11 +37,11 @@ def test_forward_passes_renderer_mm_token_type_ids_through(): position_ids, seq_lens=torch.tensor([input_ids.shape[1]]), mm_kwargs={"pixel_values": pixel_values, "image_grid_thw": image_grid_thw}, + mm_forward_policy=ForwardPolicy(pass_position_ids_with_mm=False), mm_token_type_ids=mm_token_type_ids, ) assert model.kwargs is not None - # MRoPE families (image_grid_thw present) get position_ids stripped. assert "position_ids" not in model.kwargs torch.testing.assert_close(model.kwargs["pixel_values"], pixel_values) torch.testing.assert_close(model.kwargs["image_grid_thw"], image_grid_thw) @@ -60,6 +62,7 @@ def test_forward_omits_mm_token_type_ids_when_renderer_does_not_supply(): position_ids, seq_lens=torch.tensor([input_ids.shape[1]]), mm_kwargs={"pixel_values": torch.ones(2, 3), "image_grid_thw": torch.tensor([[1, 1, 2]])}, + mm_forward_policy=ForwardPolicy(pass_position_ids_with_mm=False), ) assert model.kwargs is not None @@ -68,8 +71,7 @@ def test_forward_omits_mm_token_type_ids_when_renderer_does_not_supply(): def test_forward_keeps_position_ids_for_non_mrope_vlm(): - """Non-MRoPE VLM families (no ``image_grid_thw``) keep the trainer's - pre-computed ``position_ids``.""" + """Families whose adapter asks for position_ids keep the trainer's values.""" model = _CaptureModel(SimpleNamespace(model_type="gemma3")) input_ids = torch.tensor([[1, 10, 10, 2]]) position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0) @@ -80,7 +82,24 @@ def test_forward_keeps_position_ids_for_non_mrope_vlm(): position_ids, seq_lens=torch.tensor([input_ids.shape[1]]), mm_kwargs={"pixel_values": torch.ones(2, 3)}, + mm_forward_policy=ForwardPolicy(pass_position_ids_with_mm=True), ) assert model.kwargs is not None torch.testing.assert_close(model.kwargs["position_ids"], position_ids) + + +def test_forward_policy_can_require_mm_token_type_ids(): + model = _CaptureModel(SimpleNamespace(model_type="qwen3_vl")) + input_ids = torch.tensor([[1, 10, 10, 2]]) + position_ids = torch.arange(input_ids.shape[1]).unsqueeze(0) + + with pytest.raises(ValueError, match="mm_token_type_ids"): + forward( + model, + input_ids, + position_ids, + seq_lens=torch.tensor([input_ids.shape[1]]), + mm_kwargs={"pixel_values": torch.ones(2, 3)}, + mm_forward_policy=ForwardPolicy(requires_mm_token_type_ids=True), + ) diff --git a/tests/unit/utils/test_mm.py b/tests/unit/utils/test_mm.py new file mode 100644 index 0000000000..abb80d42a1 --- /dev/null +++ b/tests/unit/utils/test_mm.py @@ -0,0 +1,93 @@ +from types import SimpleNamespace + +import torch + +from prime_rl.multimodal.adapters.base import ForwardPolicy, MaterializedMM +from prime_rl.multimodal.schema import RAW_MM_ITEM_KIND +from prime_rl.trainer.rl.data import DataLoader +from prime_rl.transport.types import MicroBatch, MMImageRef, MMRefs +from prime_rl.utils.mm import build_mm_refs + + +class _MissingMaterializer: + def materialize(self, refs): + raise FileNotFoundError("missing image") + + def synthesize_placeholder(self, refs): + return MaterializedMM( + kwargs={ + "pixel_values": torch.zeros((1, 24), dtype=torch.float32), + "image_grid_thw": torch.tensor([[1, 1, 1]], dtype=torch.long), + }, + forward_policy=ForwardPolicy(pass_position_ids_with_mm=False), + ) + + +def _qwen_item(grid, uri: str = "file:///tmp/missing-image.png"): + return { + "kind": RAW_MM_ITEM_KIND, + "modality": "image", + "family": "qwen_vl", + "layout_fingerprint": "f" * 32, + "raw_image_uri": uri, + "payload": {"image_grid_thw": grid}, + } + + +def _refs(uri: str = "file:///tmp/missing-image.png") -> MMRefs: + return MMRefs( + images=[MMImageRef(item=_qwen_item([[1, 1, 1]], uri), hash="a" * 32, uri=uri, offset=1, length=1)], + ) + + +def _loader() -> DataLoader: + loader = object.__new__(DataLoader) + loader.multi_run_manager = SimpleNamespace(max_runs=1) + loader.mm_materializer = _MissingMaterializer() + loader.missing_mm_image_policy = "placeholder_zero_loss" + loader.last_mm_materialize_time = 0.0 + loader.last_mm_images_materialized = 0 + loader.last_mm_images_placeholdered = 0 + return loader + + +def _micro_batch() -> MicroBatch: + return MicroBatch( + input_ids=[10, 11, 12], + loss_mask=[False, True, True], + advantages=[1.5, 1.5, 1.5], + inference_logprobs=[0.0, -0.1, -0.2], + position_ids=[0, 1, 2], + sequence_lengths=[3], + seq_lens=[3], + temperatures=[1.0, 1.0, 1.0], + env_names=["env", "env", "env"], + lora_num_tokens=[3], + mm_refs=_refs(), + mm_token_type_ids=[0, 1, 0], + ) + + +def test_build_mm_refs_accepts_offloaded_file_uri(tmp_path): + image_path = tmp_path / "image.png" + image_path.write_bytes(b"image") + multi_modal_data = SimpleNamespace( + mm_items={"image": [_qwen_item([[1, 1, 1]], image_path.as_uri())]}, + mm_hashes={"image": ["a" * 32]}, + mm_placeholders={"image": [SimpleNamespace(offset=1, length=1)]}, + ) + + refs = build_mm_refs(multi_modal_data) + + assert refs == _refs(image_path.as_uri()) + + +def test_dataloader_uses_zero_loss_placeholder_for_missing_raw_image(): + tensor_batch = _loader()._micro_batch_to_tensor(_micro_batch()) + + assert tensor_batch["mm_kwargs"] is not None + assert tensor_batch["mm_kwargs"]["pixel_values"].shape == (1, 24) + assert tensor_batch["mm_forward_policy"] == ForwardPolicy(pass_position_ids_with_mm=False) + assert tensor_batch["loss_mask"].tolist() == [[False, False, False]] + assert tensor_batch["advantages"].tolist() == [[0.0, 0.0, 0.0]] + assert tensor_batch["mm_token_type_ids"].tolist() == [[0, 1, 0]] diff --git a/uv.lock b/uv.lock index 263191aea2..0e8fc133b1 100644 --- a/uv.lock +++ b/uv.lock @@ -11,7 +11,7 @@ supported-markers = [ ] [options] -exclude-newer = "2026-07-23T19:34:50.942572Z" +exclude-newer = "0001-01-01T00:00:00Z" # This has no effect and is included for backwards compatibility when using relative exclude-newer values. exclude-newer-span = "P7D" [options.exclude-newer-package] @@ -163,8 +163,8 @@ name = "aime24-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/aime24_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -178,8 +178,8 @@ name = "aime25-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/aime25_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -193,8 +193,8 @@ name = "aime26-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/aime26_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -208,7 +208,7 @@ name = "aiofile" version = "3.11.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "caio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "caio" }, ] sdist = { url = "https://files.pythonhosted.org/packages/48/41/2fea7e193e061ce54eacc3b7bc0e6a99e4fcff43c78cf0a76dd781ed8334/aiofile-3.11.1.tar.gz", hash = "sha256:1f91912c6643d2a4e49ca4ae3514f0bf3867ce948a36d99a6411b8f4755f4cf9", size = 19342, upload-time = "2026-05-16T08:18:33.538Z" } wheels = [ @@ -238,13 +238,13 @@ name = "aiohttp" version = "3.13.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohappyeyeballs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "aiosignal", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "frozenlist", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "multidict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "propcache", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "yarl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohappyeyeballs" }, + { name = "aiosignal" }, + { name = "attrs" }, + { name = "frozenlist" }, + { name = "multidict" }, + { name = "propcache" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/77/9a/152096d4808df8e4268befa55fba462f440f14beab85e8ad9bf990516918/aiohttp-3.13.5.tar.gz", hash = "sha256:9d98cc980ecc96be6eb4c1994ce35d28d8b1f5e5208a23b421187d1209dbb7d1", size = 7858271, upload-time = "2026-03-31T22:01:03.343Z" } wheels = [ @@ -268,8 +268,8 @@ name = "aiosignal" version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "frozenlist", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "frozenlist" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" } wheels = [ @@ -281,8 +281,8 @@ name = "alphabet-sort-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/alphabet_sort_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -314,14 +314,14 @@ name = "anthropic" version = "0.104.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "distro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "docstring-parser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jiter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sniffio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "distro" }, + { name = "docstring-parser" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/22/c7/7a655b948916f777354648ce979f68b94d5b8dbdb5f61fed1f37fad9378c/anthropic-0.104.1.tar.gz", hash = "sha256:17362b6c45f527afcc9b0fdf62011ffd359726ab2ebcb1978ea0cc41bd8d8d40", size = 850081, upload-time = "2026-05-22T15:36:57.432Z" } wheels = [ @@ -342,8 +342,8 @@ name = "anyio" version = "4.13.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "idna", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "idna" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" } wheels = [ @@ -355,7 +355,7 @@ name = "apache-tvm-ffi" version = "0.1.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/17/b0/5114e30faffe3279a51a5f3b45dd1b7ce09af1246b62447b45a39a374e54/apache_tvm_ffi-0.1.10.tar.gz", hash = "sha256:974c208766c304c780c17c6d405449e862f83b22c7b6b2b8c28b29d55a806ae3", size = 2691605, upload-time = "2026-04-07T19:58:51.767Z" } wheels = [ @@ -370,8 +370,8 @@ name = "apex-shortlist-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/apex_shortlist_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -403,8 +403,8 @@ name = "arxivmath-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/arxivmath_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -445,8 +445,8 @@ name = "authlib" version = "1.7.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "joserfc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cryptography" }, + { name = "joserfc" }, ] sdist = { url = "https://files.pythonhosted.org/packages/36/98/7d93f30d029643c0275dbc0bd6d5a6f670661ee6c9a94d93af7ab4887600/authlib-1.7.2.tar.gz", hash = "sha256:2cea25fefcd4e7173bdf1372c0afc265c8034b23a8cd5dcb6a9164b826c64231", size = 176511, upload-time = "2026-05-06T08:10:23.116Z" } wheels = [ @@ -458,12 +458,12 @@ name = "automation-bench" version = "1.0.5" source = { git = "https://github.com/mikasenghaas/AutomationBench.git?rev=6f0e683#6f0e6834930cf6906ed932e9c5b716206def40d7" } dependencies = [ - { name = "anthropic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anthropic" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "rich" }, + { name = "verifiers" }, ] [[package]] @@ -471,11 +471,11 @@ name = "automationbench-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/tool_use/automationbench_v1" } dependencies = [ - { name = "automation-bench", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "automation-bench" }, + { name = "datasets" }, + { name = "mcp" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -547,8 +547,8 @@ name = "beautifulsoup4" version = "4.15.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "soupsieve", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "soupsieve" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/43/65/318323f98dbee45d42dff61d8f047181bc6f2268a9068cfad035a46be5af/beautifulsoup4-4.15.0.tar.gz", hash = "sha256:288e3ca7d54b06f2ac191970bc275c1939cb46d450b255bf6718b04aa37ab4f7", size = 632571, upload-time = "2026-06-07T16:44:20.453Z" } wheels = [ @@ -560,38 +560,38 @@ name = "bfcl-eval" version = "0.0.0.dev0" source = { git = "https://github.com/mikasenghaas/gorilla.git?subdirectory=berkeley-function-call-leaderboard&rev=898763a#898763a09361c06138c844454c143db1fda15ce4" } dependencies = [ - { name = "anthropic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "beautifulsoup4", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "boto3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cohere", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datamodel-code-generator", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "faiss-cpu", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "google-genai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "google-search-results", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "html2text", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mistralai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mpmath", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "networkx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "overrides", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "qwen-agent", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rank-bm25", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sentence-transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tabulate", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tree-sitter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tree-sitter-java", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tree-sitter-javascript", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "writer-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anthropic" }, + { name = "beautifulsoup4" }, + { name = "boto3" }, + { name = "cohere" }, + { name = "datamodel-code-generator" }, + { name = "faiss-cpu" }, + { name = "filelock" }, + { name = "google-genai" }, + { name = "google-search-results" }, + { name = "html2text" }, + { name = "huggingface-hub" }, + { name = "mistralai" }, + { name = "mpmath" }, + { name = "networkx" }, + { name = "numpy" }, + { name = "openai" }, + { name = "overrides" }, + { name = "pandas" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "qwen-agent" }, + { name = "rank-bm25" }, + { name = "requests" }, + { name = "sentence-transformers" }, + { name = "tabulate" }, + { name = "tenacity" }, + { name = "tqdm" }, + { name = "tree-sitter" }, + { name = "tree-sitter-java" }, + { name = "tree-sitter-javascript" }, + { name = "typer" }, + { name = "writer-sdk" }, ] [[package]] @@ -599,9 +599,9 @@ name = "bfcl-v3-v1" version = "0.3.0" source = { editable = "deps/research-environments/environments/tool_use/bfcl_v3_v1" } dependencies = [ - { name = "bfcl-eval", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "soundfile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "bfcl-eval" }, + { name = "soundfile" }, + { name = "verifiers" }, ] [package.metadata] @@ -616,12 +616,12 @@ name = "black" version = "26.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mypy-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pathspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytokens", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "click" }, + { name = "mypy-extensions" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "pytokens" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c0/37/5628dd55bf2b34257fc7603f0fe97c40e3aaf24265f416a9c85c95ca1436/black-26.5.1.tar.gz", hash = "sha256:dd321f668053961824bcc1be1cc1df748b2d7e4fa28086b08331e577b0100a73", size = 679439, upload-time = "2026-05-18T16:53:36.107Z" } wheels = [ @@ -646,7 +646,7 @@ name = "blis" version = "1.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d0/d0/d8cc8c9a4488a787e7fa430f6055e5bd1ddb22c340a751d9e901b82e2efe/blis-1.3.3.tar.gz", hash = "sha256:034d4560ff3cc43e8aa37e188451b0440e3261d989bb8a42ceee865607715ecd", size = 2644873, upload-time = "2025-11-17T12:28:30.511Z" } wheels = [ @@ -661,7 +661,7 @@ name = "bm25s" version = "0.3.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7c/ab/39d08d4589dad6f5735a6b03ee083088dc37fba57fa45d4a0749393b9295/bm25s-0.3.9.tar.gz", hash = "sha256:895c679d952b7de8355edb5f3e1a620a1e2f294d1d42b919bf0821cce2e2f597", size = 80528, upload-time = "2026-05-13T23:08:20.952Z" } wheels = [ @@ -673,9 +673,9 @@ name = "boto3" version = "1.43.40" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "botocore", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jmespath", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "s3transfer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "botocore" }, + { name = "jmespath" }, + { name = "s3transfer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3b/43/38cdaf9c7bb50f0922ef87e6b6696c6aa589d978e4311a8287537e84ecf7/boto3-1.43.40.tar.gz", hash = "sha256:a7108b9ce25b8f92d1ce96b9e35090794d5c58b219ff2f6a7a65c8986a4ed6f4", size = 112655, upload-time = "2026-07-03T00:28:26.776Z" } wheels = [ @@ -687,9 +687,9 @@ name = "botocore" version = "1.43.40" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jmespath", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "jmespath" }, + { name = "python-dateutil" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d0/50/269986277f852cc83029bccbdcdc0b343a685cfd570599e58029792808d8/botocore-1.43.40.tar.gz", hash = "sha256:2085a4314cfd2c8bc1d08ab8039f76c92e99278db0d2a0e2437010526d5d5d70", size = 15639899, upload-time = "2026-07-03T00:28:16.125Z" } wheels = [ @@ -713,13 +713,13 @@ name = "browsecomp-plus-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/browsecomp_plus_v1" } dependencies = [ - { name = "bm25s", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pystemmer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "bm25s" }, + { name = "datasets" }, + { name = "mcp" }, + { name = "openai" }, + { name = "pystemmer" }, + { name = "tokenizers" }, + { name = "verifiers" }, ] [package.metadata] @@ -738,9 +738,9 @@ name = "browsecomp-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/browsecomp_v1" } dependencies = [ - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -755,8 +755,8 @@ name = "build" version = "1.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyproject-hooks", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "packaging" }, + { name = "pyproject-hooks" }, ] sdist = { url = "https://files.pythonhosted.org/packages/78/e0/df5e171f685f82f37b12e1f208064e24244911079d7b767447d1af7e0d70/build-1.5.0.tar.gz", hash = "sha256:302c22c3ba2a0fd5f3911918651341ebb3896176cbdec15bd421f80b1afc7647", size = 89796, upload-time = "2026-04-30T03:18:25.17Z" } wheels = [ @@ -831,7 +831,7 @@ name = "cffi" version = "2.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pycparser", marker = "(implementation_name != 'PyPy' and platform_machine == 'aarch64' and sys_platform == 'linux') or (implementation_name != 'PyPy' and platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pycparser", marker = "implementation_name != 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/eb/56/b1ba7935a17738ae8453301356628e8147c79dbb825bcbc73dc7401f9846/cffi-2.0.0.tar.gz", hash = "sha256:44d1b5909021139fe36001ae048dbdde8214afa20200eda0f64c068cac5d5529", size = 523588, upload-time = "2025-09-08T23:24:04.541Z" } wheels = [ @@ -879,9 +879,9 @@ name = "charxiv-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/multimodal/charxiv_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "pillow" }, + { name = "verifiers" }, ] [package.metadata] @@ -902,33 +902,33 @@ name = "chromadb" version = "1.5.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "bcrypt", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "build", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "grpcio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "importlib-resources", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "kubernetes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mmh3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "onnxruntime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-grpc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "orjson", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "overrides", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pybase64", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-settings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pypika", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "bcrypt" }, + { name = "build" }, + { name = "grpcio" }, + { name = "httpx" }, + { name = "importlib-resources" }, + { name = "jsonschema" }, + { name = "kubernetes" }, + { name = "mmh3" }, + { name = "numpy" }, + { name = "onnxruntime" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-grpc" }, + { name = "opentelemetry-sdk" }, + { name = "orjson" }, + { name = "overrides" }, + { name = "pybase64" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pypika" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "tenacity" }, + { name = "tokenizers" }, + { name = "tqdm" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "uvicorn", extra = ["standard"] }, ] sdist = { url = "https://files.pythonhosted.org/packages/92/d1/5e33b26985f0c7046a0be1cee2158ada1748ee700d2545057fde1468d74d/chromadb-1.5.9.tar.gz", hash = "sha256:5c20e62a455c28bacac927f26116a73fd8e1799e0d908be8e8a4f02197a54731", size = 2595635, upload-time = "2026-05-05T05:54:51.713Z" } wheels = [ @@ -941,9 +941,9 @@ name = "clbench-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/long_context/clbench_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -985,7 +985,7 @@ name = "code-golf-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/code_golf_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -996,14 +996,14 @@ name = "cohere" version = "7.0.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastavro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-core", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "types-requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastavro" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "pydantic-core" }, + { name = "requests" }, + { name = "tokenizers" }, + { name = "types-requests" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/78/23/cbb8ef34b8395ecea3cef2464d6abcb25174853fe8ad948841204f81f9a8/cohere-7.0.5.tar.gz", hash = "sha256:7fc682bb5c408402fc5ce59322bfa3f6aae27bde1ecc2450b0a25370040707ed", size = 208820, upload-time = "2026-06-29T20:30:53.132Z" } wheels = [ @@ -1015,8 +1015,8 @@ name = "color-codeword-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/color_codeword_v1" } dependencies = [ - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pillow" }, + { name = "verifiers" }, ] [package.metadata] @@ -1039,7 +1039,7 @@ name = "compact" version = "0.1.0" source = { editable = "deps/verifiers/environments/compact" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -1050,10 +1050,10 @@ name = "compressed-tensors" version = "0.17.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "loguru", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "loguru" }, + { name = "pydantic" }, + { name = "torch" }, + { name = "transformers" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2c/9e/d7f18bd9a0354088abc11a0c1f2c7698f7c49e5a709faedf6a46e388f693/compressed_tensors-0.17.0.tar.gz", hash = "sha256:15c20d06bdbcf35b51fc99fd125e7b9be1e1855567c33b7a46dfac26ad6fb126", size = 257091, upload-time = "2026-06-03T16:49:17.208Z" } wheels = [ @@ -1074,8 +1074,8 @@ name = "connect-python" version = "0.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyqwest", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "protobuf" }, + { name = "pyqwest" }, ] sdist = { url = "https://files.pythonhosted.org/packages/74/fc/0e4798c53e2754f5de36ecf4d198706cb23711d603df6c008f6e7b5b21ae/connect_python-0.9.0.tar.gz", hash = "sha256:a188ec843b0f5953b7e1b88061af50ad91c9aaa2e982d7a89a63ae5c1fff932e", size = 46094, upload-time = "2026-03-19T02:40:42.279Z" } wheels = [ @@ -1087,7 +1087,7 @@ name = "contourpy" version = "1.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/58/01/1253e6698a07380cd31a736d248a3f2a50a7c88779a1813da27503cadc2a/contourpy-1.3.3.tar.gz", hash = "sha256:083e12155b210502d0bca491432bb04d56dc3432f95a979b429f2848c3dbe880", size = 13466174, upload-time = "2025-07-26T12:03:12.549Z" } wheels = [ @@ -1102,7 +1102,7 @@ name = "cryptography" version = "48.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9f/a9/db8f313fdcd85d767d4973515e1db101f9c71f95fced83233de224673757/cryptography-48.0.0.tar.gz", hash = "sha256:5c3932f4436d1cccb036cb0eaef46e6e2db91035166f1ad6505c3c9d5a635920", size = 832984, upload-time = "2026-05-04T22:59:38.133Z" } wheels = [ @@ -1129,7 +1129,7 @@ name = "cuda-bindings" version = "12.9.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-pathfinder", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cuda-pathfinder" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/50/04/8a4d45dc154a8a32982658cc55be291e9778d1197834b15d33427e2f65c1/cuda_bindings-12.9.6-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0ea331bc47d9988cc61f0ecc5fa8df9dd188b4493ae1c6688bb1ee8ce8ba1af4", size = 7050347, upload-time = "2026-03-11T14:47:35.221Z" }, @@ -1149,7 +1149,7 @@ name = "cuda-python" version = "12.9.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-bindings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cuda-bindings" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/57/69/4a79126959ad6f1653504122ee1eb22d089dd6272d3fa37694dcdeb78ba5/cuda_python-12.9.6-py3-none-any.whl", hash = "sha256:ed5cf30e1129729eecf4605dff6e8bce84f2d30c17b17c7e5ac4b76448de35d2", size = 7596, upload-time = "2026-03-11T15:35:17.282Z" }, @@ -1160,7 +1160,7 @@ name = "cuda-tile" version = "1.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/7c/6d/cc2fb5a25689a501564a2eced4acf654f307e801a2c1506be97c0d100491/cuda_tile-1.5.0-cp312-cp312-manylinux2014_aarch64.whl", hash = "sha256:87652483baa9c81a9a24e4450f016e4ee78fd205d8422dad8996571bd1f2622e", size = 322641, upload-time = "2026-07-08T01:49:23.388Z" }, @@ -1177,37 +1177,37 @@ wheels = [ [package.optional-dependencies] cublas = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cublas-cu12" }, ] cudart = [ - { name = "nvidia-cuda-runtime-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cuda-runtime-cu12" }, ] cufft = [ - { name = "nvidia-cufft-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cufft-cu12" }, ] cufile = [ - { name = "nvidia-cufile-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cufile-cu12" }, ] cupti = [ - { name = "nvidia-cuda-cupti-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cuda-cupti-cu12" }, ] curand = [ - { name = "nvidia-curand-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-curand-cu12" }, ] cusolver = [ - { name = "nvidia-cusolver-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cusolver-cu12" }, ] cusparse = [ - { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cusparse-cu12" }, ] nvjitlink = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-nvjitlink-cu12" }, ] nvrtc = [ - { name = "nvidia-cuda-nvrtc-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cuda-nvrtc-cu12" }, ] nvtx = [ - { name = "nvidia-nvtx-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-nvtx-cu12" }, ] [[package]] @@ -1224,10 +1224,10 @@ name = "cyclopts" version = "4.21.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "docstring-parser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich-rst", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, + { name = "docstring-parser" }, + { name = "rich" }, + { name = "rich-rst" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d9/53/977540be379b0c82550df872912446def343ab0dfa138b8726120427f83d/cyclopts-4.21.0.tar.gz", hash = "sha256:477c18c791c924cca4836f79fce000a7bae45f551e340d9e1654e102c6d9ab9d", size = 190914, upload-time = "2026-07-09T19:07:07.154Z" } wheels = [ @@ -1251,15 +1251,15 @@ name = "dashscope" version = "1.26.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx-sse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websocket-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "certifi" }, + { name = "cryptography" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "requests" }, + { name = "rich" }, + { name = "typer" }, + { name = "websocket-client" }, ] sdist = { url = "https://files.pythonhosted.org/packages/36/66/23894b267d5811299a1a40ecc38302525b27c198c071f37c832341d28d92/dashscope-1.26.2.tar.gz", hash = "sha256:2ab2b6059872bde4fef2f1d77268ddc21bad09ad282cace266437eda526c3932", size = 1420273, upload-time = "2026-07-02T08:20:24.353Z" } wheels = [ @@ -1271,8 +1271,8 @@ name = "dataclasses-json" version = "0.6.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "marshmallow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "marshmallow" }, + { name = "typing-inspect" }, ] sdist = { url = "https://files.pythonhosted.org/packages/64/a4/f71d9cf3a5ac257c993b5ca3f93df5f7fb395c725e7f1e6479d2514173c3/dataclasses_json-0.6.7.tar.gz", hash = "sha256:b6b3e528266ea45b9535223bc53ca645f5208833c29229e847b3f26a1cc55fc0", size = 32227, upload-time = "2024-06-09T16:20:19.103Z" } wheels = [ @@ -1284,14 +1284,14 @@ name = "datamodel-code-generator" version = "0.68.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "argcomplete", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "black", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "genson", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "inflect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "isort", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "argcomplete" }, + { name = "black" }, + { name = "genson" }, + { name = "inflect" }, + { name = "isort" }, + { name = "jinja2" }, + { name = "pydantic" }, + { name = "pyyaml" }, ] sdist = { url = "https://files.pythonhosted.org/packages/56/6e/4d9a96931b619d7cf6ceb5bcc0026330fd045455e2b4cd45af168d94ef91/datamodel_code_generator-0.68.0.tar.gz", hash = "sha256:2b5d64a6104478c8b4a04ba17ad285e075871b14e4a374bbdddb689b642d6b7e", size = 1565609, upload-time = "2026-07-06T07:03:23.584Z" } wheels = [ @@ -1303,20 +1303,20 @@ name = "datasets" version = "4.6.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dill", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fsspec", extra = ["http"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "multiprocess", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyarrow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "xxhash", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { 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://files.pythonhosted.org/packages/d7/94/eb81c6fe32e9b6ef92223141b5a553aeff2e9456968424a8533cbe88f476/datasets-4.6.1.tar.gz", hash = "sha256:140ce500bc41939ff6ce995702d66b1f4b2ee7f117bb9b07512fab6804d4070a", size = 593865, upload-time = "2026-02-27T23:26:49.482Z" } wheels = [ @@ -1391,8 +1391,8 @@ name = "deepdiff" version = "9.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cachebox", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "orderly-set", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cachebox" }, + { name = "orderly-set" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f9/6b/6a4a5aaf38535eb332c2856aa08e73ed7c549d0851b1215401af0a2db1a7/deepdiff-9.1.0.tar.gz", hash = "sha256:07e9e366fab4297755153c4eab795ad4ef3cbd0d51660e847f5751c6bd727687", size = 382149, upload-time = "2026-05-15T20:18:05.751Z" } wheels = [ @@ -1404,9 +1404,9 @@ name = "deepdive-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/deepdive_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -1421,7 +1421,7 @@ name = "deepwiki-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/deepwiki_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -1432,7 +1432,7 @@ name = "deprecation" version = "2.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5a/d3/8ae2869247df154b64c1884d7346d412fed0c49df84db635aab2d1c40e62/deprecation-2.1.0.tar.gz", hash = "sha256:72b3bde64e5d778694b0cf68178aed03d15e15477116add3fb773e581f9518ff", size = 173788, upload-time = "2020-04-20T14:23:38.738Z" } wheels = [ @@ -1444,8 +1444,8 @@ name = "depyf" version = "0.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "astor", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "dill", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "astor" }, + { name = "dill" }, ] sdist = { url = "https://files.pythonhosted.org/packages/88/35/83fb0178212279aa0af031031905804c6de5618435d229f41ed21bb9ad2c/depyf-0.20.0.tar.gz", hash = "sha256:fb7683bd72c44f67b56029df2c47721e9a02ffa4d7b19095f1c54c4ebf797a98", size = 6168761, upload-time = "2025-10-13T12:33:38.589Z" } wheels = [ @@ -1475,9 +1475,9 @@ name = "dion" version = "0.1.0" source = { git = "https://github.com/samsja/dion.git?rev=d891eeb#d891eebbd950a6ff11d9b5f806282e33df83df9d" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "triton", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "torch" }, + { name = "triton" }, ] [[package]] @@ -1485,7 +1485,7 @@ name = "dirhash" version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "scantree", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "scantree" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1d/70/49f93897f3a4f7ab5f20a854ebc91aad47854e9fb2cd169e3a4452fa3f5e/dirhash-0.5.0.tar.gz", hash = "sha256:e60760f0ab2e935d8cb088923ea2c6492398dca42cec785df778985fd4cd5386", size = 21377, upload-time = "2024-08-03T22:14:13.322Z" } wheels = [ @@ -1524,8 +1524,8 @@ name = "docker" version = "7.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "requests" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/91/9b/4a2ea29aeba62471211598dac5d96825bb49348fa07e906ea930394a83ce/docker-7.1.0.tar.gz", hash = "sha256:ad8c70e6e3f8926cb8a92619b832b4ea5299e2831c14284663184e200546fa6c", size = 117834, upload-time = "2024-05-23T11:13:57.216Z" } wheels = [ @@ -1546,7 +1546,7 @@ name = "dotenv" version = "0.9.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "python-dotenv" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/b2/b7/545d2c10c1fc15e48653c91efde329a790f2eecfbbf2bd16003b5db2bab0/dotenv-0.9.9-py2.py3-none-any.whl", hash = "sha256:29cf74a087b31dafdb5a446b6d7e11cbce8ed2741540e2339c69fbef92c94ce9", size = 1892, upload-time = "2025-02-19T22:15:01.647Z" }, @@ -1575,8 +1575,8 @@ name = "email-validator" version = "2.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dnspython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "idna", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "dnspython" }, + { name = "idna" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f5/22/900cb125c76b7aaa450ce02fd727f452243f2e91a61af068b40adba60ea9/email_validator-2.3.0.tar.gz", hash = "sha256:9fc05c37f2f6cf439ff414f8fc46d917929974a82244c20eb10231ba60c54426", size = 51238, upload-time = "2025-08-26T13:09:06.831Z" } wheels = [ @@ -1597,8 +1597,8 @@ name = "enterprise-ops-gym-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/tool_use/enterprise_ops_gym_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -1621,7 +1621,7 @@ name = "exceptiongroup" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/50/79/66800aadf48771f6b62f7eb014e352e5d06856655206165d775e675a02c9/exceptiongroup-1.3.1.tar.gz", hash = "sha256:8b412432c6055b0b7d14c310000ae93352ed6754f70fa8f7c34141f91c4e3219", size = 30371, upload-time = "2025-11-21T23:01:54.787Z" } wheels = [ @@ -1642,8 +1642,8 @@ name = "faiss-cpu" version = "1.14.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "packaging" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/7c/8a/b451af4b3c6dd18749ecfb58ccb68503b77e49c9aa4a89d950e9d521e058/faiss_cpu-1.14.3-cp310-abi3-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1d734cfa9ac90b6a5dfed3a27cb706d05f22824703dafc3969b4e2071877a31c", size = 9661210, upload-time = "2026-06-13T02:19:06.99Z" }, @@ -1675,11 +1675,11 @@ name = "fastapi" version = "0.136.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "annotated-doc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "annotated-doc" }, + { name = "pydantic" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, ] sdist = { url = "https://files.pythonhosted.org/packages/81/2d/ff8d91d7b564d464629a0fd50a4489c97fcb836ac230bf3a7269232a9b1f/fastapi-0.136.3.tar.gz", hash = "sha256:e487fae93ad408e6f47641ee4dfe389864fd7bec92e547ea8498fc13f43e83ab", size = 396410, upload-time = "2026-05-23T18:53:15.192Z" } wheels = [ @@ -1688,15 +1688,15 @@ wheels = [ [package.optional-dependencies] standard = [ - { name = "email-validator", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastapi-cli", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastar", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-extra-types", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-settings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-multipart", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "email-validator" }, + { name = "fastapi-cli", extra = ["standard"] }, + { name = "fastar" }, + { name = "httpx" }, + { name = "jinja2" }, + { name = "pydantic-extra-types" }, + { name = "pydantic-settings" }, + { name = "python-multipart" }, + { name = "uvicorn", extra = ["standard"] }, ] [[package]] @@ -1704,9 +1704,9 @@ name = "fastapi-cli" version = "0.0.24" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "rich-toolkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "rich-toolkit" }, + { name = "typer" }, + { name = "uvicorn", extra = ["standard"] }, ] sdist = { url = "https://files.pythonhosted.org/packages/6e/58/74797ae9e4610cfa0c6b34c8309096d3b20bb29be3b8b5fbf1004d10fa5f/fastapi_cli-0.0.24.tar.gz", hash = "sha256:1afc9c9e21d7ebc8a3ca5e31790cd8d837742be7e4f8b9236e99cb3451f0de00", size = 19043, upload-time = "2026-02-24T10:45:10.476Z" } wheels = [ @@ -1715,8 +1715,8 @@ wheels = [ [package.optional-dependencies] standard = [ - { name = "fastapi-cloud-cli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastapi-cloud-cli" }, + { name = "uvicorn", extra = ["standard"] }, ] [[package]] @@ -1724,15 +1724,15 @@ name = "fastapi-cloud-cli" version = "0.18.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "detect-installer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastar", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", extra = ["email"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich-toolkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rignore", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sentry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", extra = ["standard"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "detect-installer" }, + { name = "fastar" }, + { name = "httpx" }, + { name = "pydantic", extra = ["email"] }, + { name = "rich-toolkit" }, + { name = "rignore" }, + { name = "sentry-sdk" }, + { name = "typer" }, + { name = "uvicorn", extra = ["standard"] }, ] sdist = { url = "https://files.pythonhosted.org/packages/7f/1d/57221a834b0f62dfa510c2b3db6e9b682cfbc280cef41919a8811ce1ff89/fastapi_cloud_cli-0.18.0.tar.gz", hash = "sha256:95f7a79200e3a90a005e068a4d8ede49d4b04accb095ccd4fd47da998fc28c74", size = 53320, upload-time = "2026-05-22T09:53:54.462Z" } wheels = [ @@ -1777,7 +1777,7 @@ name = "fastmcp" version = "3.4.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastmcp-slim", extra = ["client", "server"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastmcp-slim", extra = ["client", "server"] }, ] sdist = { url = "https://files.pythonhosted.org/packages/9c/f7/5188565d1b93ad611cbd80bf473e7ad669d1f3b689c4bedcd304e1ec3472/fastmcp-3.4.4.tar.gz", hash = "sha256:378202e26ec15b23819d9a1c0d1b0ebda096bc712720532010a0b82a45c2b1df", size = 28796458, upload-time = "2026-07-09T00:32:41.352Z" } wheels = [ @@ -1789,12 +1789,12 @@ name = "fastmcp-slim" version = "3.4.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", extra = ["email"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-settings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "platformdirs" }, + { name = "pydantic", extra = ["email"] }, + { name = "pydantic-settings" }, + { name = "python-dotenv" }, + { name = "rich" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/45/79/f35661c6a1d76dfbe17a079f912d96fffcfdd40fad5a9144bb9e7dfb1fdf/fastmcp_slim-3.4.4.tar.gz", hash = "sha256:dcaa3e0be2127d7eacdce592c2ef0039204923dc0ec396454615cb4a3275b078", size = 590203, upload-time = "2026-07-09T00:32:20.531Z" } wheels = [ @@ -1803,36 +1803,36 @@ wheels = [ [package.optional-dependencies] client = [ - { name = "authlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "exceptiongroup", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "authlib" }, + { name = "exceptiongroup" }, + { name = "httpx" }, + { name = "mcp" }, + { name = "opentelemetry-api" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "starlette" }, ] server = [ - { name = "authlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cyclopts", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "exceptiongroup", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "griffelib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "joserfc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonref", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema-path", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openapi-pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyperclip", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-multipart", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uncalled-for", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "watchfiles", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "authlib" }, + { name = "cyclopts" }, + { name = "exceptiongroup" }, + { name = "griffelib" }, + { name = "httpx" }, + { name = "joserfc" }, + { name = "jsonref" }, + { name = "jsonschema-path" }, + { name = "mcp" }, + { name = "openapi-pydantic" }, + { name = "opentelemetry-api" }, + { name = "packaging" }, + { name = "py-key-value-aio", extra = ["filetree", "keyring", "memory"] }, + { name = "pyperclip" }, + { name = "python-multipart" }, + { name = "pyyaml" }, + { name = "starlette" }, + { name = "uncalled-for" }, + { name = "uvicorn" }, + { name = "watchfiles" }, + { name = "websockets" }, ] [[package]] @@ -1840,7 +1840,7 @@ name = "fastsafetensors" version = "0.3.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c8/33/c97b2bcbe06e0f011eedee0f41d4060f6344901a53c2703acc3dd7429713/fastsafetensors-0.3.2.tar.gz", hash = "sha256:9e358fce238684613a5c3ebb7800c52c5b3270c0bb5e4ed2191ee8f3d0431de1", size = 70409, upload-time = "2026-05-22T05:39:34.787Z" } wheels = [ @@ -1874,8 +1874,8 @@ name = "flash-attn" version = "2.8.3+cu128torch2.11" source = { url = "https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.9.4/flash_attn-2.8.3+cu128torch2.11-cp312-cp312-linux_x86_64.whl" } dependencies = [ - { name = "einops", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torch", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "einops" }, + { name = "torch" }, ] wheels = [ { url = "https://github.com/mjun0812/flash-attention-prebuild-wheels/releases/download/v0.9.4/flash_attn-2.8.3+cu128torch2.11-cp312-cp312-linux_x86_64.whl", hash = "sha256:a16162f436286cc03ebbfb174c0853343ed98ae13c37abf1042947668ec40549" }, @@ -1892,10 +1892,10 @@ name = "flash-attn-3" version = "3.0.0" source = { registry = "https://download.pytorch.org/whl/test/cu128" } dependencies = [ - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ninja", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "einops" }, + { name = "ninja" }, + { name = "packaging" }, + { name = "torch" }, ] wheels = [ { url = "https://download.pytorch.org/whl/test/cu128/flash_attn_3-3.0.0-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:10a730d5e1a1c23afd930ce419ee425cd1925a16b7eac789dfe98c3ca39bc009", upload-time = "2026-02-14T04:28:12Z" }, @@ -1907,13 +1907,13 @@ name = "flash-attn-4" version = "4.0.0b11.dev11+g96bd151" source = { git = "https://github.com/Dao-AILab/flash-attention.git?subdirectory=flash_attn%2Fcute&rev=96bd151#96bd151b00add1dc5744115cfc350c0a809c3fa2" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cutlass-dsl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "quack-kernels", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch-c-dlpack-ext", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "einops" }, + { name = "nvidia-cutlass-dsl" }, + { name = "quack-kernels" }, + { name = "torch" }, + { name = "torch-c-dlpack-ext" }, + { name = "typing-extensions" }, ] [[package]] @@ -1921,8 +1921,8 @@ name = "flash-linear-attention" version = "0.5.2" source = { git = "https://github.com/fla-org/flash-linear-attention#a95475391465272cd3dc11e47d4a7772522dc9b7" } dependencies = [ - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "einops" }, + { name = "transformers" }, ] [[package]] @@ -1930,20 +1930,20 @@ name = "flashinfer-python" version = "0.6.14" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cuda-tile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ninja", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cudnn-frontend", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cutlass-dsl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-ml-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tabulate", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "click" }, + { name = "cuda-tile" }, + { name = "einops" }, + { name = "ninja" }, + { name = "numpy" }, + { name = "nvidia-cudnn-frontend" }, + { name = "nvidia-cutlass-dsl" }, + { name = "nvidia-ml-py" }, + { name = "packaging" }, + { name = "requests" }, + { name = "tabulate" }, + { name = "torch" }, + { name = "tqdm" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8f/11/ce2271271bee6990d34ed2d01288e9e92a0ea8ee45fb28de8e746c7da761/flashinfer_python-0.6.14.tar.gz", hash = "sha256:f4da8b5e005601784e85e0dcaa3389f908ee2d32c2560142d67124ab10e4a070", size = 9944949, upload-time = "2026-07-02T00:22:50.879Z" } wheels = [ @@ -1976,8 +1976,8 @@ name = "forth-lang-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/code/forth_lang_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -1991,9 +1991,9 @@ name = "frontierscience-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/science/frontierscience_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -2021,9 +2021,9 @@ name = "fs" version = "2.4.16" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "appdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "six", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "appdirs" }, + { name = "setuptools" }, + { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5d/a9/af5bfd5a92592c16cdae5c04f68187a309be8a146b528eac3c6e30edbad2/fs-2.4.16.tar.gz", hash = "sha256:ae97c7d51213f4b70b6a958292530289090de3a7e15841e108fbe144f069d313", size = 187441, upload-time = "2022-05-02T09:25:54.22Z" } wheels = [ @@ -2041,7 +2041,7 @@ wheels = [ [package.optional-dependencies] http = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, ] [[package]] @@ -2049,8 +2049,8 @@ name = "general-agent-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/tool_use/general_agent_v1" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, + { name = "verifiers", extra = ["harbor"] }, ] [package.metadata] @@ -2082,7 +2082,7 @@ name = "ghapi" version = "1.0.16" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastcore", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastcore" }, ] sdist = { url = "https://files.pythonhosted.org/packages/35/6e/4979d4ff930b808295373a8d44a319ffc201d7b31e6f181f53b1301b93fa/ghapi-1.0.16.tar.gz", hash = "sha256:85929ec9401a3b6f996bdd3dc53880f7ab5018bb6b15141a3a496c0862c46b5f", size = 81887, upload-time = "2026-07-06T08:15:24.149Z" } wheels = [ @@ -2094,7 +2094,7 @@ name = "gitdb" version = "4.0.12" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "smmap", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "smmap" }, ] sdist = { url = "https://files.pythonhosted.org/packages/72/94/63b0fc47eb32792c7ba1fe1b694daec9a63620db1e313033d18140c2320a/gitdb-4.0.12.tar.gz", hash = "sha256:5ef71f855d191a3326fcfbc0d5da835f26b13fbcba60c32c21091c349ffdb571", size = 394684, upload-time = "2025-01-02T07:20:46.413Z" } wheels = [ @@ -2112,7 +2112,7 @@ name = "gitpython" version = "3.1.50" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "gitdb", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "gitdb" }, ] sdist = { url = "https://files.pythonhosted.org/packages/33/f6/354ae6491228b5eb40e10d89c4d13c651fe1cf7556e35ebdded50cff57ce/gitpython-3.1.50.tar.gz", hash = "sha256:80da2d12504d52e1f998772dc5baf6e553f8d2fcfe1fcc226c9d9a2ee3372dcc", size = 219798, upload-time = "2026-05-06T04:01:26.571Z" } wheels = [ @@ -2124,7 +2124,7 @@ name = "glossary-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/glossary_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -2135,8 +2135,8 @@ name = "google-auth" version = "2.55.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyasn1-modules", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cryptography" }, + { name = "pyasn1-modules" }, ] sdist = { url = "https://files.pythonhosted.org/packages/81/1c/70b23fc52b2bb3c70b379f3bd05c4a60ab3a873e30c6bd21c57e0154848a/google_auth-2.55.0.tar.gz", hash = "sha256:fcd3a130f575fa36403d38774af1c64a4fbfbca09215f0589d2372b5119697cb", size = 349379, upload-time = "2026-06-15T22:33:16.466Z" } wheels = [ @@ -2145,7 +2145,7 @@ wheels = [ [package.optional-dependencies] requests = [ - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "requests" }, ] [[package]] @@ -2153,16 +2153,16 @@ name = "google-genai" version = "2.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "distro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "google-auth", extra = ["requests"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sniffio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "distro" }, + { name = "google-auth", extra = ["requests"] }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "requests" }, + { name = "sniffio" }, + { name = "tenacity" }, + { name = "typing-extensions" }, + { name = "websockets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/51/75/81c01294db3a3005dc8a807ed889a10ecd66ef89462c118adcffa5f7981c/google_genai-2.9.0.tar.gz", hash = "sha256:a8a10e9113f460cc668c1d9deeb62ba393ad1ba704bf3166d5a0f32a434f9415", size = 595700, upload-time = "2026-06-19T08:23:42.718Z" } wheels = [ @@ -2174,7 +2174,7 @@ name = "google-search-results" version = "2.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/77/30/b3a6f6a2e00f8153549c2fa345c58ae1ce8e5f3153c2fe0484d444c3abcb/google_search_results-2.4.2.tar.gz", hash = "sha256:603a30ecae2af8e600b22635757a6df275dad4b934f975e67878ccd640b78245", size = 18818, upload-time = "2023-03-10T11:13:09.953Z" } @@ -2183,7 +2183,7 @@ name = "googleapis-common-protos" version = "1.75.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "protobuf" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b5/c8/f439cffde755cffa462bfbb156278fa6f9d09119719af9814b858fd4f81f/googleapis_common_protos-1.75.0.tar.gz", hash = "sha256:53a062ff3c32552fbd62c11fe23768b78e4ddf0494d5e5fd97d3f4689c75fbbd", size = 151035, upload-time = "2026-05-07T08:04:49.423Z" } wheels = [ @@ -2195,9 +2195,9 @@ name = "gpqa-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/science/gpqa_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -2212,33 +2212,33 @@ name = "gradio" version = "6.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "brotli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gradio-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "groovy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "hf-gradio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "markupsafe", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "orjson", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-multipart", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytz", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "safehttpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "semantic-version", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomlkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "brotli" }, + { name = "fastapi" }, + { name = "gradio-client" }, + { name = "groovy" }, + { name = "hf-gradio" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "jinja2" }, + { name = "markupsafe" }, + { name = "numpy" }, + { name = "orjson" }, + { name = "packaging" }, + { name = "pandas" }, + { name = "pillow" }, + { name = "pydantic" }, + { name = "pydub" }, + { name = "python-multipart" }, + { name = "pytz" }, + { name = "pyyaml" }, + { name = "safehttpx" }, + { name = "semantic-version" }, + { name = "starlette" }, + { name = "tomlkit" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "uvicorn" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f8/96/3618f8a189180ab3d4e5f8b258fd92e419eda9f49b6ab4dd50c6782cda33/gradio-6.20.0.tar.gz", hash = "sha256:8672866e9225a1f8297325a6742bb525a3a0ddc8aa4d75d99beb10a27ea2915f", size = 44844340, upload-time = "2026-07-07T18:53:57.402Z" } wheels = [ @@ -2250,11 +2250,11 @@ name = "gradio-client" version = "2.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fsspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fsspec" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "packaging" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e8/e6/6b6029f5fe2ad7f1211105d530e34d991014c2cae463f9223033031cfc4f/gradio_client-2.5.0.tar.gz", hash = "sha256:4cde99bad62149595c30c90876ca2e405e3a13687ecf895474f3412cb476673d", size = 59013, upload-time = "2026-04-20T23:16:21.518Z" } wheels = [ @@ -2266,8 +2266,8 @@ name = "graphwalks-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/graphwalks_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -2299,7 +2299,7 @@ name = "grpcio" version = "1.80.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" } wheels = [ @@ -2314,8 +2314,8 @@ name = "grpclib" version = "0.4.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "h2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "multidict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "h2" }, + { name = "multidict" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5b/28/5a2c299ec82a876a252c5919aa895a6f1d1d35c96417c5ce4a4660dc3a80/grpclib-0.4.9.tar.gz", hash = "sha256:cc589c330fa81004c6400a52a566407574498cb5b055fa927013361e21466c46", size = 84798, upload-time = "2025-12-14T22:23:14.349Z" } wheels = [ @@ -2327,7 +2327,7 @@ name = "gsm8k-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/gsm8k_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, ] [package.metadata] @@ -2338,10 +2338,10 @@ name = "gymnasium" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cloudpickle", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "farama-notifications", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cloudpickle" }, + { name = "farama-notifications" }, + { name = "numpy" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4d/ff/14b6880d703dfaca204490979d3254ccd280c99550798993319902873658/gymnasium-1.3.0.tar.gz", hash = "sha256:6939e86e835d6b71b6ba6bfd360487420876deafc79bfb7bacba83a7c446bcf3", size = 830646, upload-time = "2026-04-22T13:47:14.155Z" } wheels = [ @@ -2362,8 +2362,8 @@ name = "h2" version = "4.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "hpack", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "hyperframe", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "hpack" }, + { name = "hyperframe" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1d/17/afa56379f94ad0fe8defd37d6eb3f89a25404ffc71d4d848893d270325fc/h2-4.3.0.tar.gz", hash = "sha256:6c59efe4323fa18b47a632221a1888bd7fde6249819beda254aeca909f221bf1", size = 2152026, upload-time = "2025-08-23T18:12:19.778Z" } wheels = [ @@ -2375,27 +2375,27 @@ name = "harbor" version = "0.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dirhash", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "litellm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pathspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyjwt", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "shortuuid", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "supabase", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "dirhash" }, + { name = "fastapi" }, + { name = "filelock" }, + { name = "httpx" }, + { name = "jinja2" }, + { name = "litellm" }, + { name = "packaging" }, + { name = "pathspec" }, + { name = "platformdirs" }, + { name = "pydantic" }, + { name = "pyjwt" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "rich" }, + { name = "shortuuid" }, + { name = "supabase" }, + { name = "tenacity" }, + { name = "toml" }, + { name = "typer" }, + { name = "uvicorn" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1e/da/5a26998c6e7d9455321ab39bc8e9122993892ece13c3ad4f2b0de986aaf6/harbor-0.20.0.tar.gz", hash = "sha256:e2e5e88f772690fd121553ca34fd5d6dd6b4aaa51c8fae635abc84b112303112", size = 1590870, upload-time = "2026-07-18T21:25:22.578Z" } wheels = [ @@ -2407,8 +2407,8 @@ name = "hf-gradio" version = "0.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "gradio-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "gradio-client" }, + { name = "typer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ce/86/c9694b7cfada5780e75769e60dc161a161f4dd7fc91b61db5e3a3338bef9/hf_gradio-0.4.1.tar.gz", hash = "sha256:a017d942618f0d495a58ee4563047fa04bef614c00e0cb789a9a6d0633cffa7b", size = 6560, upload-time = "2026-04-22T14:01:32.334Z" } wheels = [ @@ -2432,10 +2432,10 @@ name = "hle-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/knowledge/hle_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "pillow" }, + { name = "verifiers" }, ] [package.metadata] @@ -2469,8 +2469,8 @@ name = "httpcore" version = "1.0.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "h11", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "certifi" }, + { name = "h11" }, ] sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" } wheels = [ @@ -2494,10 +2494,10 @@ name = "httpx" version = "0.28.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpcore", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "idna", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "certifi" }, + { name = "httpcore" }, + { name = "idna" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" } wheels = [ @@ -2506,7 +2506,7 @@ wheels = [ [package.optional-dependencies] http2 = [ - { name = "h2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "h2" }, ] [[package]] @@ -2523,15 +2523,15 @@ name = "huggingface-hub" version = "1.16.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fsspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "hf-xet", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "hf-xet" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tqdm" }, + { name = "typer" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/48/0f/ed994dbade67a54407c28cab96ef845e0e6d25500be56aca6394f8bfc9dd/huggingface_hub-1.16.1.tar.gz", hash = "sha256:7f1dc4c5ec21aed69be630ad0c3378616be16f3de1a47b141c0e812965d9c832", size = 792534, upload-time = "2026-05-21T18:40:00.908Z" } wheels = [ @@ -2543,8 +2543,8 @@ name = "humaneval-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/code/humaneval_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -2558,16 +2558,16 @@ name = "humming-kernels" version = "0.1.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-bindings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-ml-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyelftools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "safetensors", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tabulate", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "triton", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cuda-bindings" }, + { name = "jinja2" }, + { name = "numpy" }, + { name = "nvidia-ml-py" }, + { name = "pyelftools" }, + { name = "safetensors" }, + { name = "tabulate" }, + { name = "torch" }, + { name = "tqdm" }, + { name = "triton" }, ] sdist = { url = "https://files.pythonhosted.org/packages/51/4f/6977a31451c3f7aa1deaa76506d6cdeb74ef418ad8bcba2e98f7510b26ec/humming_kernels-0.1.10.tar.gz", hash = "sha256:da3e46fb9fc9eba2a9327c2e8135ead68e390c955acd7449f97ee7c71666c8b1", size = 220110, upload-time = "2026-07-02T10:22:57.687Z" } wheels = [ @@ -2576,10 +2576,10 @@ wheels = [ [package.optional-dependencies] cu12 = [ - { name = "nvidia-cuda-cccl-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cuda-nvcc-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cuda-nvrtc-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cuda-runtime-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cuda-cccl-cu12" }, + { name = "nvidia-cuda-nvcc-cu12" }, + { name = "nvidia-cuda-nvrtc-cu12" }, + { name = "nvidia-cuda-runtime-cu12" }, ] [[package]] @@ -2596,9 +2596,9 @@ name = "i3-code-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/code/i3_code_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "orjson", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "orjson" }, + { name = "verifiers" }, ] [package.metadata] @@ -2613,11 +2613,11 @@ name = "i3-logic-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/reasoning/i3_logic_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "markdown", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "math-verify", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sympy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "markdown" }, + { name = "math-verify" }, + { name = "sympy" }, + { name = "verifiers" }, ] [package.metadata] @@ -2634,8 +2634,8 @@ name = "i3-math-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/i3_math_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -2649,8 +2649,8 @@ name = "i3-science-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/science/i3_science_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -2682,16 +2682,16 @@ name = "ifbench-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/if/ifbench_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "emoji", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "immutabledict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "langdetect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nltk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pip", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "spacy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "syllapy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "emoji" }, + { name = "immutabledict" }, + { name = "langdetect" }, + { name = "nltk" }, + { name = "pip" }, + { name = "setuptools" }, + { name = "spacy" }, + { name = "syllapy" }, + { name = "verifiers" }, ] [package.metadata] @@ -2713,11 +2713,11 @@ name = "ifeval-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/if/ifeval_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "immutabledict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "langdetect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nltk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "immutabledict" }, + { name = "langdetect" }, + { name = "nltk" }, + { name = "verifiers" }, ] [package.metadata] @@ -2755,7 +2755,7 @@ name = "importlib-metadata" version = "8.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "zipp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "zipp" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e7/72/c600ae4f68c28fc19f9c31b9403053e5dbb8cace2e6842c7b7c3e4d42fe9/importlib_metadata-8.9.0.tar.gz", hash = "sha256:58850626cef4bd2df100378b0f2aea9724a7b92f10770d547725b047078f99ee", size = 56140, upload-time = "2026-03-20T16:56:26.362Z" } wheels = [ @@ -2776,8 +2776,8 @@ name = "inflect" version = "7.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "more-itertools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typeguard", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "more-itertools" }, + { name = "typeguard" }, ] sdist = { url = "https://files.pythonhosted.org/packages/78/c6/943357d44a21fd995723d07ccaddd78023eace03c1846049a2645d4324a3/inflect-7.5.0.tar.gz", hash = "sha256:faf19801c3742ed5a05a8ce388e0d8fe1a07f8d095c82201eb904f5d27ad571f", size = 73751, upload-time = "2024-12-28T17:11:18.897Z" } wheels = [ @@ -2816,18 +2816,18 @@ name = "ipykernel" version = "7.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "comm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "debugpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ipython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jupyter-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jupyter-core", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "matplotlib-inline", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nest-asyncio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "psutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyzmq", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tornado", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { 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://files.pythonhosted.org/packages/ca/8d/b68b728e2d06b9e0051019640a40a9eb7a88fcd82c2e1b5ce70bef5ff044/ipykernel-7.2.0.tar.gz", hash = "sha256:18ed160b6dee2cbb16e5f3575858bc19d8f1fe6046a9a680c708494ce31d909e", size = 176046, upload-time = "2026-02-06T16:43:27.403Z" } wheels = [ @@ -2839,16 +2839,16 @@ name = "ipython" version = "9.13.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "decorator", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ipython-pygments-lexers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jedi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "matplotlib-inline", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pexpect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prompt-toolkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "psutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "stack-data", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "decorator" }, + { name = "ipython-pygments-lexers" }, + { name = "jedi" }, + { name = "matplotlib-inline" }, + { name = "pexpect" }, + { name = "prompt-toolkit" }, + { name = "psutil" }, + { name = "pygments" }, + { name = "stack-data" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cd/c4/87cda5842cf5c31837c06ddb588e11c3c35d8ece89b7a0108c06b8c9b00a/ipython-9.13.0.tar.gz", hash = "sha256:7e834b6afc99f020e3f05966ced34792f40267d64cb1ea9043886dab0dde5967", size = 4430549, upload-time = "2026-04-24T12:24:55.221Z" } wheels = [ @@ -2860,7 +2860,7 @@ name = "ipython-pygments-lexers" version = "1.1.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ef/4c/5dd1d8af08107f88c7f741ead7a40854b8ac24ddf9ae850afbcf698aa552/ipython_pygments_lexers-1.1.1.tar.gz", hash = "sha256:09c0138009e56b6854f9535736f4171d855c8c08a563a0dcd8022f78355c7e81", size = 8393, upload-time = "2025-01-17T11:24:34.505Z" } wheels = [ @@ -2872,11 +2872,11 @@ name = "ipywidgets" version = "8.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "comm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ipython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jupyterlab-widgets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "widgetsnbextension", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "comm" }, + { name = "ipython" }, + { name = "jupyterlab-widgets" }, + { name = "traitlets" }, + { name = "widgetsnbextension" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4c/ae/c5ce1edc1afe042eadb445e95b0671b03cee61895264357956e61c0d2ac0/ipywidgets-8.1.8.tar.gz", hash = "sha256:61f969306b95f85fba6b6986b7fe45d73124d1d9e3023a8068710d47a22ea668", size = 116739, upload-time = "2025-11-01T21:18:12.393Z" } wheels = [ @@ -2897,7 +2897,7 @@ name = "jaraco-classes" version = "3.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "more-itertools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "more-itertools" }, ] sdist = { url = "https://files.pythonhosted.org/packages/06/c0/ed4a27bc5571b99e3cff68f8a9fa5b56ff7df1c2251cc715a652ddd26402/jaraco.classes-3.4.0.tar.gz", hash = "sha256:47a024b51d0239c0dd8c8540c6c7f484be3b8fcf0b2d85c13825780d3b3f3acd", size = 11780, upload-time = "2024-03-31T07:27:36.643Z" } wheels = [ @@ -2918,7 +2918,7 @@ name = "jaraco-functools" version = "4.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "more-itertools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "more-itertools" }, ] sdist = { url = "https://files.pythonhosted.org/packages/36/cf/ea4ef2920830dea3f5ab2ea4da6fb67724e6dca80ee2553788c3607243d0/jaraco_functools-4.5.0.tar.gz", hash = "sha256:3bb5665ea4a020cf78a7040e89154c77edadb3ca74f366479669c5999aa70b03", size = 20272, upload-time = "2026-05-15T21:34:10.025Z" } wheels = [ @@ -2930,7 +2930,7 @@ name = "jaxtyping" version = "0.3.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wadler-lindig", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "wadler-lindig" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5d/b3/e0be221f95bbf92ea9dd34b04393130ce79fc11357add40bdd0fd4db72c8/jaxtyping-0.3.10.tar.gz", hash = "sha256:7e79b050257bb1c757ee2c3d4ba246bd54422dc785b25f24797a8ce014f6daca", size = 46251, upload-time = "2026-05-24T15:22:22.996Z" } wheels = [ @@ -2942,7 +2942,7 @@ name = "jedi" version = "0.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "parso", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "parso" }, ] sdist = { url = "https://files.pythonhosted.org/packages/46/b7/a3635f6a2d7cf5b5dd98064fc1d5fbbafcb25477bcea204a3a92145d158b/jedi-0.20.0.tar.gz", hash = "sha256:c3f4ccbd276696f4b19c54618d4fb18f9fc24b0aef02acf704b23f487daa1011", size = 3119416, upload-time = "2026-05-01T23:38:47.814Z" } wheels = [ @@ -2963,7 +2963,7 @@ name = "jinja2" version = "3.1.6" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markupsafe", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "markupsafe" }, ] sdist = { url = "https://files.pythonhosted.org/packages/df/bf/f7da0350254c0ed7c72f3e33cef02e048281fec7ecec5f032d4aac52226b/jinja2-3.1.6.tar.gz", hash = "sha256:0137fb05990d35f1275a587e9aee6d56da821fc83491a0fb838183be43f66d6d", size = 245115, upload-time = "2025-03-05T20:05:02.478Z" } wheels = [ @@ -3007,7 +3007,7 @@ name = "joserfc" version = "1.7.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cryptography" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d4/c6/b1cac0280f8efc57626ea8804866b37099f23cae11b1485a42b213245e31/joserfc-1.7.3.tar.gz", hash = "sha256:116955c2587139dba20621fd0bd7fc9255fa960c9fe7f43c43ebef2e801dcfcf", size = 233821, upload-time = "2026-07-08T12:41:42.66Z" } wheels = [ @@ -3028,7 +3028,7 @@ name = "jsonlines" version = "4.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, ] sdist = { url = "https://files.pythonhosted.org/packages/35/87/bcda8e46c88d0e34cad2f09ee2d0c7f5957bccdb9791b0b934ec84d84be4/jsonlines-4.0.0.tar.gz", hash = "sha256:0c6d2c09117550c089995247f605ae4cf77dd1533041d366351f6f298822ea74", size = 11359, upload-time = "2023-09-01T12:34:44.187Z" } wheels = [ @@ -3049,10 +3049,10 @@ name = "jsonschema" version = "4.26.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema-specifications", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "referencing", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rpds-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, + { name = "jsonschema-specifications" }, + { name = "referencing" }, + { name = "rpds-py" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b3/fc/e067678238fa451312d4c62bf6e6cf5ec56375422aee02f9cb5f909b3047/jsonschema-4.26.0.tar.gz", hash = "sha256:0c26707e2efad8aa1bfc5b7ce170f3fccc2e4918ff85989ba9ffa9facb2be326", size = 366583, upload-time = "2026-01-07T13:41:07.246Z" } wheels = [ @@ -3064,10 +3064,10 @@ name = "jsonschema-path" version = "0.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pathable", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "referencing", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, + { name = "pathable" }, + { name = "pyyaml" }, + { name = "referencing" }, ] sdist = { url = "https://files.pythonhosted.org/packages/39/79/cd02a4df6d9270efdc7d3feefe6edd730b0820c39eeaa107a2faee8322d5/jsonschema_path-0.5.0.tar.gz", hash = "sha256:493b156ba895c97602655b620a8456caa2ce08c1aa389f5a7addec065e6e855c", size = 19597, upload-time = "2026-05-19T20:45:00.971Z" } wheels = [ @@ -3079,7 +3079,7 @@ name = "jsonschema-specifications" version = "2025.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "referencing", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "referencing" }, ] sdist = { url = "https://files.pythonhosted.org/packages/19/74/a633ee74eb36c44aa6d1095e7cc5569bebf04342ee146178e2d36600708b/jsonschema_specifications-2025.9.1.tar.gz", hash = "sha256:b540987f239e745613c7a9176f3edb72b832a4ac465cf02712288397832b5e8d", size = 32855, upload-time = "2025-09-08T01:34:59.186Z" } wheels = [ @@ -3100,11 +3100,11 @@ name = "jupyter-client" version = "8.8.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jupyter-core", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyzmq", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tornado", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "jupyter-core" }, + { name = "python-dateutil" }, + { name = "pyzmq" }, + { name = "tornado" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/05/e4/ba649102a3bc3fbca54e7239fb924fd434c766f855693d86de0b1f2bec81/jupyter_client-8.8.0.tar.gz", hash = "sha256:d556811419a4f2d96c869af34e854e3f059b7cc2d6d01a9cd9c85c267691be3e", size = 348020, upload-time = "2026-01-08T13:55:47.938Z" } wheels = [ @@ -3116,8 +3116,8 @@ name = "jupyter-core" version = "5.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "platformdirs" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/02/49/9d1284d0dc65e2c757b74c6687b6d319b02f822ad039e5c512df9194d9dd/jupyter_core-5.9.1.tar.gz", hash = "sha256:4d09aaff303b9566c3ce657f580bd089ff5c91f5f89cf7d8846c3cdf465b5508", size = 89814, upload-time = "2025-10-16T19:19:18.444Z" } wheels = [ @@ -3138,11 +3138,11 @@ name = "kernels" version = "0.14.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "kernels-data", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomlkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "kernels-data" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "tomlkit" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cd/16/d9c473289d72d07a5c8e00367e5de9326bf0135e65ba74a235e2eb2510f2/kernels-0.14.1.tar.gz", hash = "sha256:ba21b7b509b7a0c2d2c7a0efd546e9dda2b1022ed5ff2b8fde8e94d7637754d3", size = 62800, upload-time = "2026-05-14T06:42:36.234Z" } wheels = [ @@ -3166,11 +3166,11 @@ name = "keyring" version = "25.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jaraco-classes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jaraco-context", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jaraco-functools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jeepney", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "secretstorage", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "jaraco-classes" }, + { name = "jaraco-context" }, + { name = "jaraco-functools" }, + { name = "jeepney" }, + { name = "secretstorage" }, ] sdist = { url = "https://files.pythonhosted.org/packages/43/4b/674af6ef2f97d56f0ab5153bf0bfa28ccb6c3ed4d1babf4305449668807b/keyring-25.7.0.tar.gz", hash = "sha256:fe01bd85eb3f8fb3dd0405defdeac9a5b4f6f0439edbb3149577f244a2e8245b", size = 63516, upload-time = "2025-11-16T16:26:09.482Z" } wheels = [ @@ -3195,16 +3195,16 @@ name = "kubernetes" version = "36.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "durationpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests-oauthlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "six", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websocket-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "certifi" }, + { name = "durationpy" }, + { name = "python-dateutil" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "requests-oauthlib" }, + { name = "six" }, + { name = "urllib3" }, + { name = "websocket-client" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2f/57/8b538af5076bc3372949d76f70ba3449bdfe52f9e6488170fa5d4f7cbe70/kubernetes-36.0.2.tar.gz", hash = "sha256:03551fcb49cae1f708f63624041e37403545b7aaed10cbf54e2b01a37a5438e3", size = 2336738, upload-time = "2026-06-01T18:20:30.785Z" } wheels = [ @@ -3216,7 +3216,7 @@ name = "kuhn-poker-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/kuhn_poker_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -3227,7 +3227,7 @@ name = "langdetect" version = "1.0.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "six", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/72/a3add0e4eec4eb9e2569554f7c70f4a3c27712f40e3284d483e88094cc0e/langdetect-1.0.9.tar.gz", hash = "sha256:cbc1fef89f8d062739774bd51eda3da3274006b3661d199c2655f6b3f6d605a0", size = 981474, upload-time = "2021-05-07T07:54:13.562Z" } @@ -3236,14 +3236,14 @@ name = "langfuse" version = "4.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "backoff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-http", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wrapt", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "backoff" }, + { name = "httpx" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-http" }, + { name = "opentelemetry-sdk" }, + { name = "packaging" }, + { name = "pydantic" }, + { name = "wrapt" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2c/74/a6f1a99893ee6d1a69439ae7eb92f8fe8806103492dc26531d5942dbd3bf/langfuse-4.7.1.tar.gz", hash = "sha256:f9e262eceedb353b191c1da1f8452d1e8ebf52297ca20e160cda0206608e3a40", size = 320620, upload-time = "2026-05-29T18:06:22.435Z" } wheels = [ @@ -3264,8 +3264,8 @@ name = "latex2sympy2-extended" version = "1.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "antlr4-python3-runtime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sympy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "antlr4-python3-runtime" }, + { name = "sympy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/30/75/456da2da05f6380ea96e6ea804ab2c03e41fc3ed80052307fe8efe6ea20e/latex2sympy2_extended-1.11.0.tar.gz", hash = "sha256:9695657c81b50abba2636638638618db59f4663ed2a4a12d62cef74a40e28fec", size = 207023, upload-time = "2026-01-10T01:43:21.319Z" } wheels = [ @@ -3277,8 +3277,8 @@ name = "lean-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/lean_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -3292,7 +3292,7 @@ name = "linkify-it-py" version = "2.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "uc-micro-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "uc-micro-py" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2e/c9/06ea13676ef354f0af6169587ae292d3e2406e212876a413bf9eece4eb23/linkify_it_py-2.1.0.tar.gz", hash = "sha256:43360231720999c10e9328dc3691160e27a718e280673d444c38d7d3aaa3b98b", size = 29158, upload-time = "2026-03-01T07:48:47.683Z" } wheels = [ @@ -3304,18 +3304,18 @@ name = "litellm" version = "1.87.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastuuid", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "importlib-metadata", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tiktoken", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "click" }, + { name = "fastuuid" }, + { name = "httpx" }, + { name = "importlib-metadata" }, + { name = "jinja2" }, + { name = "jsonschema" }, + { name = "openai" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "tiktoken" }, + { name = "tokenizers" }, ] sdist = { url = "https://files.pythonhosted.org/packages/77/0d/ccdf682ccfd7f18bf0e179c39d85616b8f8ef05a798588285310412db13d/litellm-1.87.0.tar.gz", hash = "sha256:cafc1882cb0cbab8374c41180af86e4a067796e4524e15f59e99f6e689cd1bd8", size = 15453755, upload-time = "2026-06-02T03:53:29.076Z" } wheels = [ @@ -3327,9 +3327,9 @@ name = "livecodebench-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/code/livecodebench_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "huggingface-hub" }, + { name = "verifiers" }, ] [package.metadata] @@ -3364,10 +3364,10 @@ name = "lm-format-enforcer" version = "0.11.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "interegular", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "interegular" }, + { name = "packaging" }, + { name = "pydantic" }, + { name = "pyyaml" }, ] sdist = { url = "https://files.pythonhosted.org/packages/84/d5/41cd417ba7dfdbbcfe46cebf81fb3dfd7c591b89897560ad05bb410a465d/lm_format_enforcer-0.11.3.tar.gz", hash = "sha256:e68081c108719cce284a9bcc889709b26ffb085a1945b5eba3a12cfa96d528da", size = 40258, upload-time = "2025-08-24T19:37:47.527Z" } wheels = [ @@ -3388,10 +3388,10 @@ name = "longbenchpro-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/long_context/longbenchpro_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytrec-eval-terrier", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "pytrec-eval-terrier" }, + { name = "verifiers" }, ] [package.metadata] @@ -3407,13 +3407,13 @@ name = "longcot" version = "0.1.0" source = { git = "https://github.com/LongHorizonReasoning/longcot.git?rev=6a569ab#6a569ab949befb1ecfaeb630a7ba1b83a41176ec" } dependencies = [ - { name = "anthropic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "chess", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "google-genai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rdkit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sympy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anthropic" }, + { name = "chess" }, + { name = "google-genai" }, + { name = "openai" }, + { name = "pyyaml" }, + { name = "rdkit" }, + { name = "sympy" }, ] [[package]] @@ -3421,9 +3421,9 @@ name = "longcot-mini-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/longcot_mini_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "longcot", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "longcot" }, + { name = "verifiers" }, ] [package.metadata] @@ -3438,9 +3438,9 @@ name = "longcot-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/longcot_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "longcot", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "longcot" }, + { name = "verifiers" }, ] [package.metadata] @@ -3455,8 +3455,8 @@ name = "longpdfs-v1" version = "0.0.1" source = { editable = "deps/research-environments/environments/long_context/longpdfs_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -3470,13 +3470,13 @@ name = "mamba-ssm" version = "2.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ninja", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "triton", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "einops" }, + { name = "ninja" }, + { name = "packaging" }, + { name = "setuptools" }, + { name = "torch" }, + { name = "transformers" }, + { name = "triton" }, ] sdist = { url = "https://files.pythonhosted.org/packages/34/67/ec89aa703da194a813e35d2ea2de8f74a7ce6991a120a29f3a0c5e30d4b9/mamba_ssm-2.3.1.tar.gz", hash = "sha256:4d529477ad94753962216d583fc8f1c127c717b7d7c875d6bbb9376366d0d761", size = 121707, upload-time = "2026-03-10T09:27:34.798Z" } @@ -3494,7 +3494,7 @@ name = "markdown-it-py" version = "4.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mdurl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "mdurl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/06/ff/7841249c247aa650a76b9ee4bbaeae59370dc8bfd2f6c01f3630c35eb134/markdown_it_py-4.2.0.tar.gz", hash = "sha256:04a21681d6fbb623de53f6f364d352309d4094dd4194040a10fd51833e418d49", size = 82454, upload-time = "2026-05-07T12:08:28.36Z" } wheels = [ @@ -3503,7 +3503,7 @@ wheels = [ [package.optional-dependencies] linkify = [ - { name = "linkify-it-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "linkify-it-py" }, ] [[package]] @@ -3523,7 +3523,7 @@ name = "marshmallow" version = "3.26.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/55/79/de6c16cc902f4fc372236926b0ce2ab7845268dcc30fb2fbb7f71b418631/marshmallow-3.26.2.tar.gz", hash = "sha256:bbe2adb5a03e6e3571b573f42527c6fe926e17467833660bebd11593ab8dfd57", size = 222095, upload-time = "2025-12-22T06:53:53.309Z" } wheels = [ @@ -3535,8 +3535,8 @@ name = "math-env-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/math_env_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -3550,7 +3550,7 @@ name = "math-verify" version = "0.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "latex2sympy2-extended", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "latex2sympy2-extended" }, ] sdist = { url = "https://files.pythonhosted.org/packages/4f/12/b8d13b581e110ac2f724a2351a8361a70fa36d057eb945d6379e8747c256/math_verify-0.9.0.tar.gz", hash = "sha256:45ac6c61344ba056b9e99a660a4bc8d044ed408f730aed68c60435aa5eec4645", size = 60329, upload-time = "2026-01-10T01:48:33.056Z" } wheels = [ @@ -3562,8 +3562,8 @@ name = "math500-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/math/math500_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -3577,15 +3577,15 @@ name = "matplotlib" version = "3.10.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "contourpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cycler", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fonttools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "kiwisolver", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyparsing", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "contourpy" }, + { name = "cycler" }, + { name = "fonttools" }, + { name = "kiwisolver" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "pyparsing" }, + { name = "python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/63/1b/4be5be87d43d327a0cf4de1a56e86f7f84c89312452406cf122efe2839e6/matplotlib-3.10.9.tar.gz", hash = "sha256:fd66508e8c6877d98e586654b608a0456db8d7e8a546eb1e2600efd957302358", size = 34811233, upload-time = "2026-04-24T00:14:13.539Z" } wheels = [ @@ -3599,7 +3599,7 @@ name = "matplotlib-inline" version = "0.2.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "traitlets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "traitlets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/bd/c0/9f7c9a46090390368a4d7bcb76bb87a4a36c421e4c0792cdb53486ffac7a/matplotlib_inline-0.2.2.tar.gz", hash = "sha256:72f3fe8fce36b70d4a5b612f899090cd0401deddc4ea90e1572b9f4bfb058c79", size = 8150, upload-time = "2026-05-08T17:33:33.49Z" } wheels = [ @@ -3611,19 +3611,19 @@ name = "mcp" version = "1.27.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx-sse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-settings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyjwt", extra = ["crypto"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-multipart", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sse-starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "httpx" }, + { name = "httpx-sse" }, + { name = "jsonschema" }, + { name = "pydantic" }, + { name = "pydantic-settings" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "python-multipart" }, + { name = "sse-starlette" }, + { name = "starlette" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, + { name = "uvicorn" }, ] sdist = { url = "https://files.pythonhosted.org/packages/38/83/d1efe7c2980d8a3afa476f4e3d42d53dd54c0ab94c27bee5d755b45c8b73/mcp-1.27.1.tar.gz", hash = "sha256:0f47e1820f8f8f941466b39749eb1d1839a04caddca2bc60e9d46e8a99914924", size = 608458, upload-time = "2026-05-08T16:50:12.601Z" } wheels = [ @@ -3635,10 +3635,10 @@ name = "mcp-atlas-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/tool_use/mcp_atlas_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "httpx" }, + { name = "prime-sandboxes" }, + { name = "verifiers" }, ] [package.metadata] @@ -3654,7 +3654,7 @@ name = "mdit-py-plugins" version = "0.6.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markdown-it-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "markdown-it-py" }, ] sdist = { url = "https://files.pythonhosted.org/packages/59/fc/f8d0863f8862f25602c0404d75568e89fb6b4109804645e5cdfb1be5cf56/mdit_py_plugins-0.6.1.tar.gz", hash = "sha256:a2bca0f039f39dbd35fb74ae1b5f998608c437463371f0ff7f49a19a17a114d0", size = 56114, upload-time = "2026-05-13T09:03:38.91Z" } wheels = [ @@ -3675,14 +3675,14 @@ name = "mistral-common" version = "1.11.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "jsonschema", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-extra-types", extra = ["pycountry"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tiktoken", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "jsonschema" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "pydantic" }, + { name = "pydantic-extra-types", extra = ["pycountry"] }, + { name = "requests" }, + { name = "tiktoken" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/6f/d0/61b2c24be62a8e2f0e46a1c16de23de386c8644408da249bc66768a6681b/mistral_common-1.11.7.tar.gz", hash = "sha256:d3b79583595cf6d96a2ab33e42cb8449768383147b8c56cac5a4f193be19d20d", size = 6387178, upload-time = "2026-07-23T09:21:17.206Z" } wheels = [ @@ -3691,7 +3691,7 @@ wheels = [ [package.optional-dependencies] image = [ - { name = "opencv-python-headless", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opencv-python-headless" }, ] [[package]] @@ -3699,16 +3699,16 @@ name = "mistralai" version = "1.12.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "eval-type-backport", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "invoke", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-http", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "eval-type-backport" }, + { name = "httpx" }, + { name = "invoke" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-http" }, + { name = "opentelemetry-sdk" }, + { name = "pydantic" }, + { name = "python-dateutil" }, + { name = "pyyaml" }, + { name = "typing-inspection" }, ] sdist = { url = "https://files.pythonhosted.org/packages/aa/12/c3476c53e907255b5f485f085ba50dd9a84b40fe662e9a888d6ded26fa7b/mistralai-1.12.4.tar.gz", hash = "sha256:e52b53bab58025dcd208eeac13e3c3df5778d4112eeca1f08124096c7738929f", size = 243129, upload-time = "2026-02-20T17:55:13.73Z" } wheels = [ @@ -3720,7 +3720,7 @@ name = "ml-dtypes" version = "0.5.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/4a/c27b42ed9b1c7d13d9ba8b6905dece787d6259152f2309338aed29b2447b/ml_dtypes-0.5.4.tar.gz", hash = "sha256:8ab06a50fb9bf9666dd0fe5dfb4676fa2b0ac0f31ecff72a6c3af8e22c063453", size = 692314, upload-time = "2025-11-17T22:32:31.031Z" } wheels = [ @@ -3745,8 +3745,8 @@ name = "mmlu-pro-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/knowledge/mmlu_pro_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -3760,9 +3760,9 @@ name = "mmmu-pro-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/multimodal/mmmu_pro_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "pillow" }, + { name = "verifiers" }, ] [package.metadata] @@ -3777,9 +3777,9 @@ name = "mmmu-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/knowledge/mmmu_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "pillow" }, + { name = "verifiers" }, ] [package.metadata] @@ -3794,19 +3794,19 @@ name = "modal" version = "1.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cbor2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "grpclib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "synchronicity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "types-certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "types-toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "watchfiles", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "cbor2" }, + { name = "certifi" }, + { name = "click" }, + { name = "grpclib" }, + { name = "protobuf" }, + { name = "rich" }, + { name = "synchronicity" }, + { name = "toml" }, + { name = "types-certifi" }, + { name = "types-toml" }, + { name = "typing-extensions" }, + { name = "watchfiles" }, ] sdist = { url = "https://files.pythonhosted.org/packages/54/56/a8d1a1dd705044e0c3534642361e8586db98908b683f8231b9fd39a86209/modal-1.5.1.tar.gz", hash = "sha256:f8fb7f4d3ccc5b774370704b1aabb79e629ea7e6681a7f9671af5cf77161be12", size = 801962, upload-time = "2026-06-23T15:44:18.853Z" } wheels = [ @@ -3818,13 +3818,13 @@ name = "model-hosting-container-standards" version = "0.1.15" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jmespath", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "supervisor", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastapi" }, + { name = "httpx" }, + { name = "jmespath" }, + { name = "pydantic" }, + { name = "setuptools" }, + { name = "starlette" }, + { name = "supervisor" }, ] sdist = { url = "https://files.pythonhosted.org/packages/03/5a/d669bdeb5ba96db42c6ef010835a25119b05f8c35ee5f1c3f715626625fe/model_hosting_container_standards-0.1.15.tar.gz", hash = "sha256:ae8dd74d3250545c14f0a7068186c7b0f0ab6563d31e7137f556b6b660c8a6a9", size = 93994, upload-time = "2026-05-05T18:22:29.357Z" } wheels = [ @@ -3836,13 +3836,13 @@ name = "modelexpress" version = "0.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "grpcio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nixl", extra = ["cu12"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "grpcio" }, + { name = "huggingface-hub" }, + { name = "nixl", extra = ["cu12"] }, + { name = "numpy" }, + { name = "protobuf" }, + { name = "pydantic" }, + { name = "torch" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/7c/b5/12f940a41940fd83b9e50ce46124695b68a80feab02612779f8fb584db09/modelexpress-0.3.0-py3-none-any.whl", hash = "sha256:6f93d8de74903f6c11ebf9b4621fa02e3c493a5e05207c38fb2c98395a774618", size = 44333, upload-time = "2026-04-17T20:17:29.478Z" }, @@ -3853,8 +3853,8 @@ name = "mooncake-transfer-engine" version = "0.3.11.post1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "requests" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/82/6c/92d517ba157a02b2612b06a00c7e3f366d1050e41cc50e1bdefa382a7dc0/mooncake_transfer_engine-0.3.11.post1-cp312-cp312-manylinux_2_35_x86_64.whl", hash = "sha256:5ea50146d0d65f0274a406db49a570d187ad04760e054a49627bf84158038ac0", size = 42661963, upload-time = "2026-05-24T12:08:40.453Z" }, @@ -3884,9 +3884,9 @@ name = "mrcr-v2-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/mrcr_v2_v1" } dependencies = [ - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "filelock" }, + { name = "httpx" }, + { name = "verifiers" }, ] [package.metadata] @@ -3925,15 +3925,15 @@ name = "multi-swe-bench" version = "1.1.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dataclasses-json", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "docker", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gitpython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pygithub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "swe-rex", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "unidiff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "dataclasses-json" }, + { name = "docker" }, + { name = "gitpython" }, + { name = "pygithub" }, + { name = "pyyaml" }, + { name = "swe-rex" }, + { name = "toml" }, + { name = "tqdm" }, + { name = "unidiff" }, ] sdist = { url = "https://files.pythonhosted.org/packages/48/ad/6b7cda600a50392c790b14ee420b9a3bb318a982a298c05f2d1c066a434f/multi_swe_bench-1.1.2.tar.gz", hash = "sha256:44944bc6608d7d9b8d4390f3ce0a3b2c69122ea6be6e35766c6fde2328f50392", size = 1267660, upload-time = "2025-12-18T07:16:09.584Z" } wheels = [ @@ -3958,7 +3958,7 @@ name = "multiprocess" version = "0.70.18" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dill", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "dill" }, ] sdist = { url = "https://files.pythonhosted.org/packages/72/fd/2ae3826f5be24c6ed87266bc4e59c46ea5b059a103f3d7e7eb76a52aeecb/multiprocess-0.70.18.tar.gz", hash = "sha256:f9597128e6b3e67b23956da07cf3d2e5cba79e2f4e0fba8d7903636663ec6d0d", size = 1798503, upload-time = "2025-04-17T03:11:27.742Z" } wheels = [ @@ -3974,9 +3974,9 @@ name = "multiswe-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/multiswe_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "multi-swe-bench", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "multi-swe-bench" }, + { name = "verifiers" }, ] [package.metadata] @@ -4051,8 +4051,8 @@ name = "nixl" version = "0.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nixl-cu12", version = "0.10.1", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nixl-cu12", version = "0.10.1", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64'" }, + { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bb/a4/10e80e623790d3fb070e966b36bced009419d483c92ae0df6645230f606f/nixl-0.10.1-py3-none-any.whl", hash = "sha256:616465673dae5180d296525a03237af4cd5f2c00c3228d185bc06dbe621509b7", size = 6680, upload-time = "2026-03-03T19:55:44.848Z" }, @@ -4060,8 +4060,8 @@ wheels = [ [package.optional-dependencies] cu12 = [ - { name = "nixl-cu12", version = "0.10.1", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "nixl-cu12", version = "0.10.1", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64'" }, + { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, ] [[package]] @@ -4072,8 +4072,8 @@ resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", ] dependencies = [ - { name = "numpy", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torch", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, + { name = "numpy" }, + { name = "torch" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/d4/21/c1f34212a3e612b5c0da389c1aa3557588d9cfc2adf864914b32e270847b/nixl_cu12-0.10.1-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:b4712c6e0f18f57fee34cd970faac01480f0caf12da33d4a40ef4e9096a4caf7", size = 50227261, upload-time = "2026-03-03T19:55:17.177Z" }, @@ -4087,8 +4087,8 @@ resolution-markers = [ "platform_machine == 'x86_64' and sys_platform == 'linux'", ] dependencies = [ - { name = "numpy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torch", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "numpy" }, + { name = "torch" }, ] wheels = [ { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl", hash = "sha256:bd01eb9e52f1affee3330062baa2f3bea7d711664f7cb602bf5d3f694daeb796" }, @@ -4105,9 +4105,9 @@ name = "nl2repobench-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/code/nl2repobench_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "prime-sandboxes" }, + { name = "verifiers", extra = ["harbor"] }, ] [package.metadata] @@ -4122,10 +4122,10 @@ name = "nltk" version = "3.9.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "joblib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "regex", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "click" }, + { name = "joblib" }, + { name = "regex" }, + { name = "tqdm" }, ] sdist = { url = "https://files.pythonhosted.org/packages/74/a1/b3b4adf15585a5bc4c357adde150c01ebeeb642173ded4d871e89468767c/nltk-3.9.4.tar.gz", hash = "sha256:ed03bc098a40481310320808b2db712d95d13ca65b27372f8a403949c8b523d0", size = 2946864, upload-time = "2026-03-24T06:13:40.641Z" } wheels = [ @@ -4146,8 +4146,8 @@ name = "numba" version = "0.65.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "llvmlite", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "llvmlite" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/49/61/7299643b9c18d669e04be7c5bcb64d985070d07553274817b45b049e7bfe/numba-0.65.0.tar.gz", hash = "sha256:edad0d9f6682e93624c00125a471ae4df186175d71fd604c983c377cdc03e68b", size = 2764131, upload-time = "2026-04-01T03:52:01.946Z" } wheels = [ @@ -4226,7 +4226,7 @@ name = "nvidia-cudnn-cu12" version = "9.22.0.52" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cublas-cu12" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/51/ff/c6a098c1e0bccc68aac5f1684526cf8936abb7024dcc46dca315b8a6f47f/nvidia_cudnn_cu12-9.22.0.52-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:cd9011812498376f866b9826331cc965ac922eb2df8549c9f2989f10255e5001", size = 774536507, upload-time = "2026-05-08T15:36:09.067Z" }, @@ -4247,7 +4247,7 @@ name = "nvidia-cufft-cu12" version = "11.3.3.83" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-nvjitlink-cu12" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/60/bc/7771846d3a0272026c416fbb7e5f4c1f146d6d80704534d0b187dd6f4800/nvidia_cufft_cu12-11.3.3.83-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:848ef7224d6305cdb2a4df928759dca7b1201874787083b6e7550dd6765ce69a", size = 193109211, upload-time = "2025-03-07T01:44:56.873Z" }, @@ -4277,9 +4277,9 @@ name = "nvidia-cusolver-cu12" version = "11.7.3.90" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cublas-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cusparse-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cublas-cu12" }, + { name = "nvidia-cusparse-cu12" }, + { name = "nvidia-nvjitlink-cu12" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/c8/32/f7cd6ce8a7690544d084ea21c26e910a97e077c9b7f07bf5de623ee19981/nvidia_cusolver_cu12-11.7.3.90-py3-none-manylinux_2_27_aarch64.whl", hash = "sha256:db9ed69dbef9715071232caa9b69c52ac7de3a95773c2db65bdba85916e4e5c0", size = 267229841, upload-time = "2025-03-07T01:46:54.356Z" }, @@ -4291,7 +4291,7 @@ name = "nvidia-cusparse-cu12" version = "12.5.8.93" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-nvjitlink-cu12" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/bc/f7/cd777c4109681367721b00a106f491e0d0d15cfa1fd59672ce580ce42a97/nvidia_cusparse_cu12-12.5.8.93-py3-none-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:9b6c161cb130be1a07a27ea6923df8141f3c295852f4b260c65f18f3e0a091dc", size = 288117129, upload-time = "2025-03-07T01:47:40.407Z" }, @@ -4312,7 +4312,7 @@ name = "nvidia-cutlass-dsl" version = "4.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "nvidia-cutlass-dsl-libs-base", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nvidia-cutlass-dsl-libs-base" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f0/15/575d7df4fe2f3406f1cfc68be72aeff2834f8a696daf1cd5bee8017e4507/nvidia_cutlass_dsl-4.5.2-py3-none-any.whl", hash = "sha256:68ed1b63ca74aae87955012da9dfd7fdaae471329d0028b229b841c7192ccf52", size = 10179, upload-time = "2026-05-25T03:38:56.364Z" }, @@ -4323,9 +4323,9 @@ name = "nvidia-cutlass-dsl-libs-base" version = "4.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cuda-python", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cuda-python" }, + { name = "numpy" }, + { name = "typing-extensions" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/b1/ef/e827e3c67d72adbf4e8f680bdf03b1b67723d9e1ae7c3d0a1751f39f69ce/nvidia_cutlass_dsl_libs_base-4.5.2-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:d2a3c412287e356fbe48fe9f845d6d33cd35dea5e20d7e4f628c20957967cacd", size = 75643473, upload-time = "2026-05-25T03:49:15.857Z" }, @@ -4401,10 +4401,10 @@ name = "onnxruntime" version = "1.26.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "flatbuffers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "flatbuffers" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "protobuf" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/f6/a0/3f9d896a0385a36bd04345d6d0b802821a5782adde562e7e135f6bb71c73/onnxruntime-1.26.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:91f2bb870a4b9224eba0a6728c1fa7a9e552b8e59e1083c51fbbc3d013f2b5c0", size = 16052692, upload-time = "2026-05-08T19:07:13.829Z" }, @@ -4416,9 +4416,9 @@ name = "oolong-pairs-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/oolong_pairs_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "huggingface-hub" }, + { name = "verifiers" }, ] [package.metadata] @@ -4433,9 +4433,9 @@ name = "oolong-real-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/oolong_real_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -4450,10 +4450,10 @@ name = "oolong-synth-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/oolong_synth_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "python-dateutil" }, + { name = "verifiers" }, ] [package.metadata] @@ -4469,14 +4469,14 @@ name = "openai" version = "2.38.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "distro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jiter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sniffio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "tqdm" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8f/12/cfa322c5f5dd8fa21aab9a7a8e979e7a11123800f86ca8d82eb68a83d213/openai-2.38.0.tar.gz", hash = "sha256:798694c6cf74145541fda94325b6f8f72d8e1fd0262cc137c8d728177a6a4ce3", size = 772764, upload-time = "2026-05-21T21:23:42.105Z" } wheels = [ @@ -4488,14 +4488,14 @@ name = "openai-agents" version = "0.17.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "griffelib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "types-requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "griffelib" }, + { name = "mcp" }, + { name = "openai" }, + { name = "pydantic" }, + { name = "requests" }, + { name = "types-requests" }, + { name = "typing-extensions" }, + { name = "websockets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fd/16/b79c1849125eb6d19cae98c21ff35caa2e55b5ec8d7a02b354b711917ef7/openai_agents-0.17.3.tar.gz", hash = "sha256:63b6dda6bd4fb51169e2a2cbd5d187a4e5ce823bbd15f965c8ed1d3b89072eec", size = 5406135, upload-time = "2026-05-19T01:28:15.971Z" } wheels = [ @@ -4507,7 +4507,7 @@ name = "openai-harmony" version = "0.0.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3e/92/2d038d096f29179c7c9571b431f9e739f87a487121901725e23fe338dd9d/openai_harmony-0.0.8.tar.gz", hash = "sha256:6e43f98e6c242fa2de6f8ea12eab24af63fa2ed3e89c06341fb9d92632c5cbdf", size = 284777, upload-time = "2025-11-05T19:07:06.727Z" } wheels = [ @@ -4522,7 +4522,7 @@ name = "openapi-pydantic" version = "0.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/02/2e/58d83848dd1a79cb92ed8e63f6ba901ca282c5f09d04af9423ec26c56fd7/openapi_pydantic-0.5.1.tar.gz", hash = "sha256:ff6835af6bde7a459fb93eb93bb92b8749b754fc6e51b2f1590a19dc3005ee0d", size = 60892, upload-time = "2025-01-08T19:29:27.083Z" } wheels = [ @@ -4534,7 +4534,7 @@ name = "opencv-python-headless" version = "4.13.0.92" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/21/76/9417a6aef9def70e467a5bf560579f816148a4c658b7d525581b356eda9e/opencv_python_headless-4.13.0.92-cp37-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c8cfc8e87ed452b5cecb9419473ee5560a989859fe1d10d1ce11ae87b09a2cb", size = 33703709, upload-time = "2026-02-05T10:24:46.469Z" }, @@ -4548,22 +4548,22 @@ name = "openenv" version = "0.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastmcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gradio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli-w", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "fastapi" }, + { name = "fastmcp" }, + { name = "gradio" }, + { name = "httpx" }, + { name = "huggingface-hub" }, + { name = "openai" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "rich" }, + { name = "tomli" }, + { name = "tomli-w" }, + { name = "typer" }, + { name = "typing-extensions" }, + { name = "uvicorn" }, + { name = "websockets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/38/5552b1b208c8b8971a1895a74f3b9e52f824059d3aa5d08992088931d969/openenv-0.4.1.tar.gz", hash = "sha256:08c7c13455854beee5c8f311f57d95180772e3e9ac9c85278d681864488016a3", size = 201919, upload-time = "2026-07-03T11:37:24.139Z" } wheels = [ @@ -4575,7 +4575,7 @@ name = "openenv-wordle-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/openenv_wordle_v1" } dependencies = [ - { name = "verifiers", extra = ["openenv"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers", extra = ["openenv"] }, ] [package.metadata] @@ -4586,8 +4586,8 @@ name = "openseeker-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/openseeker_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -4601,9 +4601,9 @@ name = "openswe-v1" version = "0.1.3" source = { editable = "deps/research-environments/environments/swe/openswe_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "huggingface-hub" }, + { name = "verifiers" }, ] [package.metadata] @@ -4618,7 +4618,7 @@ name = "opentelemetry-api" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b4/1c/125e1c936c0873796771b7f04f6c93b9f1bf5d424cea90fda94a99f61da8/opentelemetry_api-1.42.1.tar.gz", hash = "sha256:56c63bea9f77b62856be8c47600474acad853b2924b99b1687c4cb6297166716", size = 72296, upload-time = "2026-05-21T16:32:49.335Z" } wheels = [ @@ -4630,8 +4630,8 @@ name = "opentelemetry-exporter-otlp" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-exporter-otlp-proto-grpc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-http", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-exporter-otlp-proto-grpc" }, + { name = "opentelemetry-exporter-otlp-proto-http" }, ] sdist = { url = "https://files.pythonhosted.org/packages/08/94/8637919a5d01f81dacf510234bc0110b944f4687a6e96b0a02adf2f6bdce/opentelemetry_exporter_otlp-1.42.1.tar.gz", hash = "sha256:2d9ebaed714377a67d224d46795ddcc11d2c877fa5de35fda70b6f3b010729a9", size = 6086, upload-time = "2026-05-21T16:32:51.963Z" } wheels = [ @@ -4643,7 +4643,7 @@ name = "opentelemetry-exporter-otlp-proto-common" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-proto", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-proto" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0e/9c/216acfeaedadf2e1937f4373929b20f73197c5c4a2546d4f584b7fa63813/opentelemetry_exporter_otlp_proto_common-1.42.1.tar.gz", hash = "sha256:04f1f01fb597c4249dfcd7f8b861c902c2102369d376d9d346ff38de4469a2ee", size = 21433, upload-time = "2026-05-21T16:32:55.526Z" } wheels = [ @@ -4655,13 +4655,13 @@ name = "opentelemetry-exporter-otlp-proto-grpc" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "googleapis-common-protos", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "grpcio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-common", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-proto", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "googleapis-common-protos" }, + { name = "grpcio" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-common" }, + { name = "opentelemetry-proto" }, + { name = "opentelemetry-sdk" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/87/87/ca7fc790dfdbcf4f9e9aab14a39ef1b7508ead13707e283de0b3131478d2/opentelemetry_exporter_otlp_proto_grpc-1.42.1.tar.gz", hash = "sha256:975c4461f167dd8ed8857d68d3b6b25f3d272eab896f6a9470d0f5b90e2faf15", size = 27140, upload-time = "2026-05-21T16:32:56.162Z" } wheels = [ @@ -4673,13 +4673,13 @@ name = "opentelemetry-exporter-otlp-proto-http" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "googleapis-common-protos", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-exporter-otlp-proto-common", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-proto", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "googleapis-common-protos" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp-proto-common" }, + { name = "opentelemetry-proto" }, + { name = "opentelemetry-sdk" }, + { name = "requests" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/77/32/826bfa1d80ecea24f47808de03cd4a0d13c17ecc07712f45123f0f61e4ac/opentelemetry_exporter_otlp_proto_http-1.42.1.tar.gz", hash = "sha256:bf142a21035d7571ac3a09cb2e5639f49886f243972883cfe777ed3bf02b734d", size = 25406, upload-time = "2026-05-21T16:32:56.807Z" } wheels = [ @@ -4691,7 +4691,7 @@ name = "opentelemetry-proto" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "protobuf" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b4/55/63eac3e1089b768ba014091fdd2ae8a9a440c821ef5e2b786909c94c8836/opentelemetry_proto-1.42.1.tar.gz", hash = "sha256:c6a51e6b4f05ae63565f3a113217f3d2bfaec68f78c02d7a6c85f9010d1cfca6", size = 45839, upload-time = "2026-05-21T16:33:03.937Z" } wheels = [ @@ -4703,9 +4703,9 @@ name = "opentelemetry-sdk" version = "1.42.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-semantic-conventions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-semantic-conventions" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/40/f7/b390bd9bfd703bf98a68fea1f27786c6872331fd617164a54b8a59bdc008/opentelemetry_sdk-1.42.1.tar.gz", hash = "sha256:8c834e8f8c9ba4171d4ec843d0cb8a67e4c7394d3f9e9297e582cbd9456ddbf7", size = 239262, upload-time = "2026-05-21T16:33:04.641Z" } wheels = [ @@ -4717,8 +4717,8 @@ name = "opentelemetry-semantic-conventions" version = "0.63b1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-api" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/93/99/4d7dd6df64795951413ce6e815f8cf1eb191daf7196ae86574589643d5f3/opentelemetry_semantic_conventions-0.63b1.tar.gz", hash = "sha256:3daf963611334b365e98a57438183eb012d3bfb40b2d931a9af613476b8701a9", size = 148340, upload-time = "2026-05-21T16:33:05.455Z" } wheels = [ @@ -4730,8 +4730,8 @@ name = "opentelemetry-semantic-conventions-ai" version = "0.5.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "opentelemetry-semantic-conventions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-sdk" }, + { name = "opentelemetry-semantic-conventions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/24/02/10aeacc37a38a3a8fa16ff67bec1ae3bf882539f6f9efb0f70acf802ca2d/opentelemetry_semantic_conventions_ai-0.5.1.tar.gz", hash = "sha256:153906200d8c1d2f8e09bd78dbef526916023de85ac3dab35912bfafb69ff04c", size = 26533, upload-time = "2026-03-26T14:20:38.73Z" } wheels = [ @@ -4743,7 +4743,7 @@ name = "openthoughts-tblite-v1" version = "0.1.1" source = { editable = "deps/research-environments/environments/terminal/openthoughts_tblite_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -4803,8 +4803,8 @@ name = "pandas" version = "3.0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dateutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "python-dateutil" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f8/87/4341c6252d1c47b08768c3d25ac487362bf403f0313ddae4a2a26c9b1b4c/pandas-3.0.3.tar.gz", hash = "sha256:696a4a00a2a2a35d4e5deb3fc946641b96c944f02230e4f76137fe35d806c4fc", size = 4651414, upload-time = "2026-05-11T18:54:29.21Z" } wheels = [ @@ -4819,9 +4819,9 @@ name = "papersearchqa-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/papersearchqa_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -4872,8 +4872,8 @@ name = "patterned-needle-in-haystack-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/patterned_needle_in_haystack_v1" } dependencies = [ - { name = "nltk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nltk" }, + { name = "verifiers" }, ] [package.metadata] @@ -4887,7 +4887,7 @@ name = "pexpect" version = "4.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "ptyprocess", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "ptyprocess" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/92/cc564bf6381ff43ce1f4d06852fc19a2f11d180f23dc32d9588bee2f149d/pexpect-4.9.0.tar.gz", hash = "sha256:ee7d41123f3c9911050ea2c2dac107568dc43b2d3b0c7557a33212c398ead30f", size = 166450, upload-time = "2023-11-25T09:07:26.339Z" } wheels = [ @@ -4913,10 +4913,10 @@ name = "pinchbench-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/tool_use/pinchbench_v1" } dependencies = [ - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "openai" }, + { name = "prime-sandboxes" }, + { name = "pyyaml" }, + { name = "verifiers" }, ] [package.metadata] @@ -4950,8 +4950,8 @@ name = "plotly" version = "6.7.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "narwhals", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "narwhals" }, + { name = "packaging" }, ] sdist = { url = "https://files.pythonhosted.org/packages/3a/7f/0f100df1172aadf88a929a9dbb902656b0880ba4b960fe5224867159d8f4/plotly-6.7.0.tar.gz", hash = "sha256:45eea0ff27e2a23ccd62776f77eb43aa1ca03df4192b76036e380bb479b892c6", size = 6911286, upload-time = "2026-04-09T20:36:45.738Z" } wheels = [ @@ -4972,10 +4972,10 @@ name = "postgrest" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "deprecation", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", extra = ["http2"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "yarl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "deprecation" }, + { name = "httpx", extra = ["http2"] }, + { name = "pydantic" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e2/22/88c470d8838d2678a44e0172d061630b8837cba3fb7fb492e28f6578c309/postgrest-2.31.0.tar.gz", hash = "sha256:2f395d84b2ee34fc57622ff2f711df603e2ede625f98e5015240741888f7bd0c", size = 14419, upload-time = "2026-06-04T13:37:20.474Z" } wheels = [ @@ -4987,11 +4987,11 @@ name = "pre-commit" version = "4.6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cfgv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "identify", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nodeenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "virtualenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cfgv" }, + { name = "identify" }, + { name = "nodeenv" }, + { name = "pyyaml" }, + { name = "virtualenv" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8e/22/2de9408ac81acbb8a7d05d4cc064a152ccf33b3d480ebe0cd292153db239/pre_commit-4.6.0.tar.gz", hash = "sha256:718d2208cef53fdc38206e40524a6d4d9576d103eb16f0fec11c875e7716e9d9", size = 198525, upload-time = "2026-04-21T20:31:41.613Z" } wheels = [ @@ -5003,8 +5003,8 @@ name = "preshed" version = "3.0.13" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cymem", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "murmurhash", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cymem" }, + { name = "murmurhash" }, ] sdist = { url = "https://files.pythonhosted.org/packages/43/75/fe6b7bbd0dea530a001b0e24c331b21a0be2786e402abf3c57f5dce43d4b/preshed-3.0.13.tar.gz", hash = "sha256:d75f718bbfd97e992f7827e0fa7faf6a91bdd9c922d5baa4b50d62731396cb89", size = 18338, upload-time = "2026-03-23T08:57:31.378Z" } wheels = [ @@ -5019,22 +5019,22 @@ name = "prime" version = "0.6.19" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "build", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gitignore-parser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-evals", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-tunnel", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textual", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textual-plot", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "build" }, + { name = "cryptography" }, + { name = "gitignore-parser" }, + { name = "httpx" }, + { name = "prime-evals" }, + { name = "prime-sandboxes" }, + { name = "prime-tunnel" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "textual" }, + { name = "textual-plot" }, + { name = "toml" }, + { name = "tomli" }, + { name = "typer" }, + { name = "verifiers" }, ] sdist = { url = "https://files.pythonhosted.org/packages/54/01/d355265be49ec5bd5ce602791e572e266c315ba9087c1a9e77911781a99d/prime-0.6.19.tar.gz", hash = "sha256:cbf33d5050e3795373842b9b89be0ee2b11a9ae9bbdcda080272eb0d982276c2", size = 711104, upload-time = "2026-07-17T17:41:09.283Z" } wheels = [ @@ -5046,9 +5046,9 @@ name = "prime-evals" version = "0.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "tenacity" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1b/e6/8c84619b09ecfb9484ba9b14bf57de3e9417a08e0b3695bd054b181efca8/prime_evals-0.2.3.tar.gz", hash = "sha256:4b22f9057a8765c85f2e91c795d78e48015ae6d30439f24aea9e8396b2c3f016", size = 14417, upload-time = "2026-06-05T00:39:56.145Z" } wheels = [ @@ -5059,12 +5059,12 @@ wheels = [ name = "prime-pydantic-config" source = { editable = "deps/pydantic-config" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, ] [package.optional-dependencies] toml = [ - { name = "tomli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "tomli" }, ] [package.metadata] @@ -5090,101 +5090,101 @@ name = "prime-rl" version = "0.7.0" source = { editable = "." } dependencies = [ - { name = "aiolimiter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "beartype", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "dion", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "flash-linear-attention", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jaxtyping", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "loguru", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "modelexpress", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mooncake-transfer-engine", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "msgspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-ml-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "orjson", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-pydantic-config", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-rl-configs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyarrow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pybase64", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyzmq", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "renderers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ring-flash-attn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setproctitle", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tilelang", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torchao", version = "0.17.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torchao", version = "0.17.0+git02105d46c", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.6.0/torchao-0.17.0+git02105d46c-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torchaudio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torchdata", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torchtitan", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torchvision", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvloop", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "vllm", version = "0.26.0+cu129", source = { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "vllm", version = "0.26.0+cu129", source = { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "wandb", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wandb-workspaces", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiolimiter" }, + { name = "beartype" }, + { name = "datasets" }, + { name = "dion" }, + { name = "flash-linear-attention" }, + { name = "jaxtyping" }, + { name = "loguru" }, + { name = "modelexpress" }, + { name = "mooncake-transfer-engine" }, + { name = "msgspec" }, + { name = "numpy" }, + { name = "nvidia-ml-py" }, + { name = "openai" }, + { name = "orjson" }, + { name = "pandas" }, + { name = "prime" }, + { name = "prime-pydantic-config" }, + { name = "prime-rl-configs" }, + { name = "pyarrow" }, + { name = "pybase64" }, + { name = "pyzmq" }, + { name = "renderers" }, + { name = "rich" }, + { name = "ring-flash-attn" }, + { name = "setproctitle" }, + { name = "tenacity" }, + { name = "tilelang" }, + { name = "torch" }, + { name = "torchao", version = "0.17.0", source = { registry = "https://pypi.org/simple" }, marker = "platform_machine != 'x86_64'" }, + { name = "torchao", version = "0.17.0+git02105d46c", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.6.0/torchao-0.17.0+git02105d46c-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "torchaudio" }, + { name = "torchdata" }, + { name = "torchtitan" }, + { name = "torchvision" }, + { name = "transformers" }, + { name = "uvloop" }, + { name = "verifiers", extra = ["harbor"] }, + { name = "vllm", version = "0.26.0+cu129", source = { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "vllm", version = "0.26.0+cu129", source = { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "wandb" }, + { name = "wandb-workspaces" }, ] [package.optional-dependencies] all = [ - { name = "deep-ep", version = "1.1.0+1fd57b0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.1.0+1fd57b0-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "deep-ep", version = "1.2.1+29d31c0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.2.1+29d31c0-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "flash-attn", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "flash-attn-3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "flash-attn-4", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nixl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "quack-kernels", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "deep-ep", version = "1.1.0+1fd57b0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.1.0+1fd57b0-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "deep-ep", version = "1.2.1+29d31c0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.2.1+29d31c0-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "flash-attn", marker = "platform_machine == 'x86_64'" }, + { name = "flash-attn-3" }, + { name = "flash-attn-4" }, + { name = "nixl" }, + { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "quack-kernels" }, + { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, ] disagg = [ - { name = "deep-ep", version = "1.1.0+1fd57b0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.1.0+1fd57b0-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "deep-ep", version = "1.2.1+29d31c0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.2.1+29d31c0-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "nixl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "deep-ep", version = "1.1.0+1fd57b0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.1.0+1fd57b0-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "deep-ep", version = "1.2.1+29d31c0", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_ep-1.2.1+29d31c0-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "deep-gemm", version = "2.5.0+891d57b", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/deep_gemm-2.5.0+891d57b-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "nixl" }, + { name = "nixl-cu12", version = "0.10.1", source = { url = "https://github.com/PrimeIntellect-ai/prime-rl/releases/download/v0.5.0/nixl_cu12-0.10.1-cp312-cp312-linux_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, + { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_aarch64.whl" }, marker = "platform_machine != 'x86_64'" }, + { name = "vllm-router", version = "0.1.26", source = { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_x86_64.whl" }, marker = "platform_machine == 'x86_64'" }, ] flash-attn = [ - { name = "flash-attn", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "flash-attn", marker = "platform_machine == 'x86_64'" }, ] flash-attn-3 = [ - { name = "flash-attn-3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "flash-attn-3" }, ] flash-attn-cute = [ - { name = "flash-attn-4", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "flash-attn-4" }, ] gpt-oss = [ - { name = "kernels", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "kernels" }, ] quack = [ - { name = "quack-kernels", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "quack-kernels" }, ] [package.dev-dependencies] dev = [ - { name = "ipykernel", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ipywidgets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pre-commit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytest", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytest-asyncio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ruff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "ipykernel" }, + { name = "ipywidgets" }, + { name = "pre-commit" }, + { name = "pytest" }, + { name = "pytest-asyncio" }, + { name = "ruff" }, ] mamba-ssm = [ - { name = "mamba-ssm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "mamba-ssm" }, ] [package.metadata] @@ -5271,12 +5271,12 @@ name = "prime-rl-configs" version = "0.4.0" source = { editable = "packages/prime-rl-configs" } dependencies = [ - { name = "prime-pydantic-config", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "renderers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli-w", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "prime-pydantic-config" }, + { name = "pydantic" }, + { name = "renderers" }, + { name = "tomli" }, + { name = "tomli-w" }, + { name = "verifiers" }, ] [package.metadata] @@ -5294,12 +5294,12 @@ name = "prime-sandboxes" version = "0.2.33" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "aiofiles", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "connect-python", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiofiles" }, + { name = "connect-python" }, + { name = "httpx" }, + { name = "protobuf" }, + { name = "pydantic" }, + { name = "tenacity" }, ] sdist = { url = "https://files.pythonhosted.org/packages/15/a9/880685cefd503aa92d2b49da46b60ba807015f8839c344a83d8c5bc02f30/prime_sandboxes-0.2.33.tar.gz", hash = "sha256:4253a3c345ccf6c07b41a81790f8515763333f094d20bc405a257432461e81d8", size = 81228, upload-time = "2026-07-22T23:23:55.715Z" } wheels = [ @@ -5311,9 +5311,9 @@ name = "prime-tunnel" version = "0.1.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx" }, + { name = "pydantic" }, + { name = "tenacity" }, ] sdist = { url = "https://files.pythonhosted.org/packages/bf/26/7324b5b9ec117c21fc9320214bf04ecbe9144ee87ef48c7d6d6c3e3d3f7f/prime_tunnel-0.1.10.tar.gz", hash = "sha256:8bf575af659bcc107a98b0b5ec1ba3e958ea72ead535ced03c443134a1ad07ea", size = 15305, upload-time = "2026-06-17T00:01:02.392Z" } wheels = [ @@ -5325,14 +5325,14 @@ name = "programbench" version = "1.2.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "junitparser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "jinja2" }, + { name = "junitparser" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "rich" }, + { name = "tqdm" }, + { name = "typer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/81/bd/6b9c812af45f35b1389110dcd9a10275281d9e31783a5b8e092e5e157558/programbench-1.2.3.tar.gz", hash = "sha256:adfd70c9bb2f840fb8e917bbf6694eaa0c9056b7ded9c4705289533c92a4c44a", size = 3291509, upload-time = "2026-06-29T15:25:39.889Z" } wheels = [ @@ -5344,11 +5344,11 @@ name = "programbench-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/code/programbench_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "programbench", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "huggingface-hub" }, + { name = "prime-sandboxes" }, + { name = "programbench" }, + { name = "verifiers" }, ] [package.metadata] @@ -5365,7 +5365,7 @@ name = "prolog-v1" version = "0.4.0" source = { editable = "deps/research-environments/environments/reasoning/prolog_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -5385,8 +5385,8 @@ name = "prometheus-fastapi-instrumentator" version = "8.0.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "prometheus-client", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "prometheus-client" }, + { name = "starlette" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1b/e9/2065686d1dfa62296fdc158b6e8fd25b0cb3dca09b0632cabeb5ae81fe4d/prometheus_fastapi_instrumentator-8.0.2.tar.gz", hash = "sha256:3c252e748151768a7aefd66824a04a870144f71de48a67aed211749a9ca2a548", size = 21342, upload-time = "2026-06-23T09:39:31.611Z" } wheels = [ @@ -5398,7 +5398,7 @@ name = "prompt-toolkit" version = "3.0.52" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wcwidth", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "wcwidth" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a1/96/06e01a7b38dce6fe1db213e061a4602dd6032a8a97ef6c1a862537732421/prompt_toolkit-3.0.52.tar.gz", hash = "sha256:28cde192929c8e7321de85de1ddbe736f1375148b02f2e17edd840042b1be855", size = 434198, upload-time = "2025-08-27T15:24:02.057Z" } wheels = [ @@ -5423,7 +5423,7 @@ name = "proposer-solver-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/proposer_solver_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -5484,8 +5484,8 @@ name = "py-key-value-aio" version = "0.4.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "beartype", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "beartype" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fb/e2/d689d922894a7ecde73b6daeaf9b13dab5aae06fe6aaaf7514722644d382/py_key_value_aio-0.4.5.tar.gz", hash = "sha256:c6563a2c6abe5da5e20f4f9e875c2a9b425a2244a54fadbf46cf140a9eea45d7", size = 107547, upload-time = "2026-05-27T16:37:08.107Z" } wheels = [ @@ -5494,14 +5494,14 @@ wheels = [ [package.optional-dependencies] filetree = [ - { name = "aiofile", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "aiofile" }, + { name = "anyio" }, ] keyring = [ - { name = "keyring", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "keyring" }, ] memory = [ - { name = "cachetools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cachetools" }, ] [[package]] @@ -5530,7 +5530,7 @@ name = "pyasn1-modules" version = "0.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyasn1", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pyasn1" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e9/e6/78ebbb10a8c8e4b61a59249394a4a594c1a7af95593dc933a349c8d00964/pyasn1_modules-0.4.2.tar.gz", hash = "sha256:677091de870a80aae844b1ca6134f54652fa2c8c5a52aa396440ac3106e941e6", size = 307892, upload-time = "2025-03-28T02:41:22.17Z" } wheels = [ @@ -5574,10 +5574,10 @@ name = "pydantic" version = "2.13.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "annotated-types", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-core", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "annotated-types" }, + { name = "pydantic-core" }, + { name = "typing-extensions" }, + { name = "typing-inspection" }, ] sdist = { url = "https://files.pythonhosted.org/packages/18/a5/b60d21ac674192f8ab0ba4e9fd860690f9b4a6e51ca5df118733b487d8d6/pydantic-2.13.4.tar.gz", hash = "sha256:c40756b57adaa8b1efeeced5c196f3f3b7c435f90e84ea7f443901bec8099ef6", size = 844775, upload-time = "2026-05-06T13:43:05.343Z" } wheels = [ @@ -5586,7 +5586,7 @@ wheels = [ [package.optional-dependencies] email = [ - { name = "email-validator", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "email-validator" }, ] [[package]] @@ -5594,7 +5594,7 @@ name = "pydantic-argparse" version = "0.10.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, ] sdist = { url = "https://files.pythonhosted.org/packages/94/ea/e63d587294c20d3b83e9c312b5d577c9ec28962ee8490839ca9996672849/pydantic_argparse-0.10.0.tar.gz", hash = "sha256:d57eb0a84c8f0af6605376157d3f445cfd786700f2e596ba9d48d15d557185eb", size = 15928, upload-time = "2025-02-09T08:18:30.425Z" } wheels = [ @@ -5606,7 +5606,7 @@ name = "pydantic-core" version = "2.46.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9d/56/921726b776ace8d8f5db44c4ef961006580d91dc52b803c489fafd1aa249/pydantic_core-2.46.4.tar.gz", hash = "sha256:62f875393d7f270851f20523dd2e29f082bcc82292d66db2b64ea71f64b6e1c1", size = 471464, upload-time = "2026-05-06T13:37:06.98Z" } wheels = [ @@ -5623,8 +5623,8 @@ name = "pydantic-extra-types" version = "2.11.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/71/dba38ee2651f84f7842206adbd2233d8bbdb59fb85e9fa14232486a8c471/pydantic_extra_types-2.11.1.tar.gz", hash = "sha256:46792d2307383859e923d8fcefa82108b1a141f8a9c0198982b3832ab5ef1049", size = 172002, upload-time = "2026-03-16T08:08:03.92Z" } wheels = [ @@ -5633,7 +5633,7 @@ wheels = [ [package.optional-dependencies] pycountry = [ - { name = "pycountry", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pycountry" }, ] [[package]] @@ -5641,9 +5641,9 @@ name = "pydantic-settings" version = "2.14.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-inspection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, + { name = "python-dotenv" }, + { name = "typing-inspection" }, ] sdist = { url = "https://files.pythonhosted.org/packages/07/60/1d1e59c9c90d54591469ada7d268251f71c24bdb765f1a8a832cee8c6653/pydantic_settings-2.14.1.tar.gz", hash = "sha256:e874d3bec7e787b0c9958277956ed9b4dd5de6a80e162188fdaff7c5e26fd5fa", size = 235551, upload-time = "2026-05-08T13:40:06.542Z" } wheels = [ @@ -5673,11 +5673,11 @@ name = "pygithub" version = "2.9.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pyjwt", extra = ["crypto"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pynacl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pyjwt", extra = ["crypto"] }, + { name = "pynacl" }, + { name = "requests" }, + { name = "typing-extensions" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ab/c3/8465a311197e16cf5ab68789fe689535e90f6b61ab524cc32a39e67237ae/pygithub-2.9.1.tar.gz", hash = "sha256:59771d7ff63d54d427be2e7d0dad2208dfffc2b0a045fec959263787739b611c", size = 2594989, upload-time = "2026-04-14T07:26:13.622Z" } wheels = [ @@ -5704,7 +5704,7 @@ wheels = [ [package.optional-dependencies] crypto = [ - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cryptography" }, ] [[package]] @@ -5712,7 +5712,7 @@ name = "pynacl" version = "1.6.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, + { name = "cffi", marker = "platform_python_implementation != 'PyPy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d9/9a/4019b524b03a13438637b11538c82781a5eda427394380381af8f04f467a/pynacl-1.6.2.tar.gz", hash = "sha256:018494d6d696ae03c7e656e5e74cdfd8ea1326962cc401bcf018f1ed8436811c", size = 3511692, upload-time = "2026-01-01T17:48:10.851Z" } wheels = [ @@ -5777,7 +5777,7 @@ name = "pyqwest" version = "0.6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "opentelemetry-api", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "opentelemetry-api" }, ] sdist = { url = "https://files.pythonhosted.org/packages/71/54/7c155961add9446697b3a75c60a2f6a41a41e6d8bbaa8f80227838f95973/pyqwest-0.6.0.tar.gz", hash = "sha256:c5be8afb01e3913d7c4b90ec68446625d2d4714d18daadfaa779c75eaa0f4f3c", size = 450676, upload-time = "2026-05-19T03:21:06.67Z" } wheels = [ @@ -5808,10 +5808,10 @@ name = "pytest" version = "9.0.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "iniconfig", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pluggy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "iniconfig" }, + { name = "packaging" }, + { name = "pluggy" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7d/0d/549bd94f1a0a402dc8cf64563a117c0f3765662e2e668477624baeec44d5/pytest-9.0.3.tar.gz", hash = "sha256:b86ada508af81d19edeb213c681b1d48246c1a91d304c6c81a427674c17eb91c", size = 1572165, upload-time = "2026-04-07T17:16:18.027Z" } wheels = [ @@ -5823,8 +5823,8 @@ name = "pytest-asyncio" version = "1.3.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pytest", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pytest" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/90/2c/8af215c0f776415f3590cac4f9086ccefd6fd463befeae41cd4d3f193e5a/pytest_asyncio-1.3.0.tar.gz", hash = "sha256:d7f52f36d231b80ee124cd216ffb19369aa168fc10095013c6b014a34d3ee9e5", size = 50087, upload-time = "2025-11-10T16:07:47.256Z" } wheels = [ @@ -5836,7 +5836,7 @@ name = "python-dateutil" version = "2.9.0.post0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "six", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "six" }, ] sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" } wheels = [ @@ -5848,8 +5848,8 @@ name = "python-discovery" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "filelock" }, + { name = "platformdirs" }, ] sdist = { url = "https://files.pythonhosted.org/packages/48/60/e88788207d81e46362cfbef0d4aaf4c0f49efc3c12d4c3fa3f542c34ebec/python_discovery-1.3.1.tar.gz", hash = "sha256:62f6db28064c9613e7ca76cb3f00c38c839a07c31c00dfe7ed0986493d2150a6", size = 68011, upload-time = "2026-05-12T20:53:36.336Z" } wheels = [ @@ -5900,8 +5900,8 @@ name = "pytrec-eval-terrier" version = "0.5.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "scipy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "scipy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/04/96/4925a95e4865a647bc74d3bb052243d12a3c8e8a34909d7d097b5a4d08c5/pytrec_eval_terrier-0.5.10.tar.gz", hash = "sha256:eaaf20580d17b5575a233e04dab8a4cbcc01a7e45be8cf547c07f0a2bb3e7eb9", size = 18634, upload-time = "2025-10-20T16:50:18.098Z" } wheels = [ @@ -5935,7 +5935,7 @@ name = "pyzmq" version = "27.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(implementation_name == 'pypy' and platform_machine == 'aarch64' and sys_platform == 'linux') or (implementation_name == 'pypy' and platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cffi", marker = "implementation_name == 'pypy'" }, ] sdist = { url = "https://files.pythonhosted.org/packages/04/0b/3c9baedbdf613ecaa7aa07027780b8867f57b6293b6ee50de316c9f3222b/pyzmq-27.1.0.tar.gz", hash = "sha256:ac0765e3d44455adb6ddbf4417dcce460fc40a05978c08efdf2948072f6db540", size = 281750, upload-time = "2025-09-08T23:10:18.157Z" } wheels = [ @@ -5950,11 +5950,11 @@ name = "quack-kernels" version = "0.4.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "einops", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cutlass-dsl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch-c-dlpack-ext", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "einops" }, + { name = "nvidia-cutlass-dsl" }, + { name = "torch" }, + { name = "torch-c-dlpack-ext" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2a/58/58b82e91b236539f424ff5681e7095b1f2860ddfb7778fe0be14d8fb58de/quack_kernels-0.4.1.tar.gz", hash = "sha256:9d7d6ba412bc0c8a9b1331c52a73db76280adb9dc2f2750df4851ddabef1466b", size = 274766, upload-time = "2026-04-30T14:37:55.65Z" } wheels = [ @@ -5966,17 +5966,17 @@ name = "qwen-agent" version = "0.0.34" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "dashscope", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "eval-type-backport", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "json5", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonlines", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jsonschema", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tiktoken", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "dashscope" }, + { name = "dotenv" }, + { name = "eval-type-backport" }, + { name = "json5" }, + { name = "jsonlines" }, + { name = "jsonschema" }, + { name = "openai" }, + { name = "pillow" }, + { name = "pydantic" }, + { name = "requests" }, + { name = "tiktoken" }, ] sdist = { url = "https://files.pythonhosted.org/packages/0a/e2/cfe83936675f4cf098c569d9aba037168393d8849ef08d4970770ef50ec5/qwen_agent-0.0.34.tar.gz", hash = "sha256:ee47a31bf0e75c3ed870fdd903c6d348d68b73ca6e2b9f3d99b55e792d0a4b2c", size = 7061049, upload-time = "2026-02-16T08:18:45.777Z" } wheels = [ @@ -5988,8 +5988,8 @@ name = "r2e-gym-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/r2e_gym_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6003,7 +6003,7 @@ name = "rank-bm25" version = "0.2.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fc/0a/f9579384aa017d8b4c15613f86954b92a95a93d641cc849182467cf0bb3b/rank_bm25-0.2.2.tar.gz", hash = "sha256:096ccef76f8188563419aaf384a02f0ea459503fdf77901378d4fd9d87e5e51d", size = 8347, upload-time = "2022-02-16T12:10:52.196Z" } wheels = [ @@ -6015,8 +6015,8 @@ name = "rdkit" version = "2026.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "pillow" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/37/f7/10ab7321d82ef6e079560a75bb81c1ef17be8121c22b8c16c3e9c20a1df5/rdkit-2026.3.3-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f6e7493518dd526ef46cf96ea7fe77eb6bd6601848a2ae423ee3d7f5f8382753", size = 35653855, upload-time = "2026-06-05T18:42:43.628Z" }, @@ -6028,9 +6028,9 @@ name = "realtime" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, + { name = "typing-extensions" }, + { name = "websockets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/df/34/54a1eaaefa24db5cb12596fd74792e08efa53ed30dc5bce2c0a68ded6146/realtime-2.31.0.tar.gz", hash = "sha256:9e641cb4d77ca0fe768515f8cf9f83550c79f49ce1550a95afc2dc0e252be8c9", size = 18716, upload-time = "2026-06-04T13:37:22.089Z" } wheels = [ @@ -6051,8 +6051,8 @@ name = "redsearcher-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/redsearcher_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6066,9 +6066,9 @@ name = "referencing" version = "0.37.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rpds-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, + { name = "rpds-py" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/22/f5/df4e9027acead3ecc63e50fe1e36aca1523e1719559c499951bb4b53188f/referencing-0.37.0.tar.gz", hash = "sha256:44aefc3142c5b842538163acb373e24cce6632bd54bdb01b21ad5863489f50d8", size = 78036, upload-time = "2025-10-13T15:30:48.871Z" } wheels = [ @@ -6091,13 +6091,13 @@ wheels = [ name = "renderers" source = { editable = "deps/renderers" } dependencies = [ - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai-harmony", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-pydantic-config", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tiktoken", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "jinja2" }, + { name = "numpy" }, + { name = "openai" }, + { name = "openai-harmony" }, + { name = "prime-pydantic-config" }, + { name = "tiktoken" }, + { name = "transformers" }, ] [package.metadata] @@ -6106,10 +6106,14 @@ requires-dist = [ { name = "numpy" }, { name = "openai", specifier = ">=1.108.1" }, { name = "openai-harmony", specifier = ">=0.0.4" }, + { name = "pillow", marker = "extra == 'vision'", specifier = ">=12.2.0" }, { name = "prime-pydantic-config", specifier = ">=0.3.0.dev83" }, { name = "tiktoken" }, + { name = "torch", marker = "extra == 'vision'", specifier = ">=2.11.0" }, + { name = "torchvision", marker = "extra == 'vision'", specifier = ">=0.26.0" }, { name = "transformers", specifier = ">=4.50.0" }, ] +provides-extras = ["vision"] [package.metadata.requires-dev] dev = [ @@ -6128,10 +6132,10 @@ name = "requests" version = "2.34.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "charset-normalizer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "idna", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "certifi" }, + { name = "charset-normalizer" }, + { name = "idna" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ac/c3/e2a2b89f2d3e2179abd6d00ebd70bff6273f37fb3e0cc209f48b39d00cbf/requests-2.34.2.tar.gz", hash = "sha256:f288924cae4e29463698d6d60bc6a4da69c89185ad1e0bcc4104f584e960b9ed", size = 142856, upload-time = "2026-05-14T19:25:27.735Z" } wheels = [ @@ -6143,8 +6147,8 @@ name = "requests-oauthlib" version = "2.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "oauthlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "oauthlib" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/42/f2/05f29bc3913aea15eb670be136045bf5c5bbf4b99ecb839da9b422bb2c85/requests-oauthlib-2.0.0.tar.gz", hash = "sha256:b3dffaebd884d8cd778494369603a9e7b58d29111bf6b41bdc2dcd87203af4e9", size = 55650, upload-time = "2024-03-22T20:32:29.939Z" } wheels = [ @@ -6156,7 +6160,7 @@ name = "reverse-text-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/reverse_text_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, ] [package.metadata] @@ -6167,8 +6171,8 @@ name = "rich" version = "15.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markdown-it-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "markdown-it-py" }, + { name = "pygments" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c0/8f/0722ca900cc807c13a6a0c696dacf35430f72e0ec571c4275d2371fca3e9/rich-15.0.0.tar.gz", hash = "sha256:edd07a4824c6b40189fb7ac9bc4c52536e9780fbbfbddf6f1e2502c31b068c36", size = 230680, upload-time = "2026-04-12T08:24:00.75Z" } wheels = [ @@ -6180,8 +6184,8 @@ name = "rich-rst" version = "2.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pygments" }, + { name = "rich" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e2/d6/d0b9fafc73b65767200da027acab1db1bdb1048f4fea5ebf659df01c700e/rich_rst-2.1.0.tar.gz", hash = "sha256:f4d117b49697f338769759fa5cacf5197da4888b347b9fda2e50aef5cd8d93bd", size = 302732, upload-time = "2026-07-05T02:59:44.308Z" } wheels = [ @@ -6193,9 +6197,9 @@ name = "rich-toolkit" version = "0.19.10" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "click" }, + { name = "rich" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fa/02/32217f3657ae91a0ea7cf1d74ade78f44352f830d00c468f753ddb3d4980/rich_toolkit-0.19.10.tar.gz", hash = "sha256:dc2e8c515ef9fbb4894e62bd41a2d2960dd7c2f505b5084894604d5ccfee3f09", size = 198167, upload-time = "2026-05-21T10:11:42.397Z" } wheels = [ @@ -6252,8 +6256,8 @@ name = "s1-deepresearch-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/search/s1_deepresearch_v1" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "verifiers" }, ] [package.metadata] @@ -6267,7 +6271,7 @@ name = "s3transfer" version = "0.19.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "botocore", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "botocore" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f6/94/dcdaeb1713cab9c84def276cfac7388b17c7d9855bbcfe88d77e4dbafd44/s3transfer-0.19.0.tar.gz", hash = "sha256:ce436931687addc4c1712d52d40b32f53e88315723f107ffa20ba82b05a0f685", size = 165171, upload-time = "2026-06-16T19:44:51.599Z" } wheels = [ @@ -6279,7 +6283,7 @@ name = "safehttpx" version = "0.1.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx" }, ] sdist = { url = "https://files.pythonhosted.org/packages/89/d1/4282284d9cf1ee873607a46442da977fc3c985059315ab23610be31d5885/safehttpx-0.1.7.tar.gz", hash = "sha256:db201c0978c41eddb8bb480f3eee59dd67304fdd91646035e9d9a720049a9d23", size = 10385, upload-time = "2025-10-24T18:30:09.783Z" } wheels = [ @@ -6303,8 +6307,8 @@ name = "scaleswe-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/scaleswe_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6318,8 +6322,8 @@ name = "scantree" version = "0.0.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "attrs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pathspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "attrs" }, + { name = "pathspec" }, ] sdist = { url = "https://files.pythonhosted.org/packages/b3/e4/40998faefc72ba1ddeb640a44fba92935353525dba110488806da8339c0b/scantree-0.0.4.tar.gz", hash = "sha256:15bd5cb24483b04db2c70653604e8ea3522e98087db7e38ab8482f053984c0ac", size = 24643, upload-time = "2024-08-03T20:08:59.413Z" } wheels = [ @@ -6331,8 +6335,8 @@ name = "scicode-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/code/scicode_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6346,11 +6350,11 @@ name = "scikit-learn" version = "1.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "joblib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "narwhals", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "scipy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "threadpoolctl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "joblib" }, + { name = "narwhals" }, + { name = "numpy" }, + { name = "scipy" }, + { name = "threadpoolctl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fa/6f/37092bdb25f712817231799fc5674d8e704066a8a70c1d2d40517e18b4ab/scikit_learn-1.9.0.tar.gz", hash = "sha256:8833266989d3a5110178a9fae30783675460724d0e1efb13b14901d2c660c557", size = 7750767, upload-time = "2026-06-02T11:54:32.706Z" } wheels = [ @@ -6363,7 +6367,7 @@ name = "scipy" version = "1.17.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, ] sdist = { url = "https://files.pythonhosted.org/packages/7a/97/5a3609c4f8d58b039179648e62dd220f89864f56f7357f5d4f45c29eb2cc/scipy-1.17.1.tar.gz", hash = "sha256:95d8e012d8cb8816c226aef832200b1d45109ed4464303e997c5b13122b297c0", size = 30573822, upload-time = "2026-02-23T00:26:24.851Z" } wheels = [ @@ -6378,7 +6382,7 @@ name = "scratchpad-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/scratchpad_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -6389,9 +6393,9 @@ name = "seaborn" version = "0.13.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "matplotlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "matplotlib" }, + { name = "numpy" }, + { name = "pandas" }, ] sdist = { url = "https://files.pythonhosted.org/packages/86/59/a451d7420a77ab0b98f7affa3a1d78a313d2f7281a57afb1a34bae8ab412/seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7", size = 1457696, upload-time = "2024-01-25T13:21:52.551Z" } wheels = [ @@ -6403,8 +6407,8 @@ name = "secretstorage" version = "3.5.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cryptography", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jeepney", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cryptography" }, + { name = "jeepney" }, ] sdist = { url = "https://files.pythonhosted.org/packages/1c/03/e834bcd866f2f8a49a85eaff47340affa3bfa391ee9912a952a1faa68c7b/secretstorage-3.5.0.tar.gz", hash = "sha256:f04b8e4689cbce351744d5537bf6b1329c6fc68f91fa666f60a380edddcd11be", size = 19884, upload-time = "2025-11-23T19:02:53.191Z" } wheels = [ @@ -6425,7 +6429,7 @@ name = "senior-swe-bench-v1" version = "0.1.1" source = { editable = "deps/research-environments/environments/swe/senior_swe_bench_v1" } dependencies = [ - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers", extra = ["harbor"] }, ] [package.metadata] @@ -6436,14 +6440,14 @@ name = "sentence-transformers" version = "5.6.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "scikit-learn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "scipy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "scikit-learn" }, + { name = "scipy" }, + { name = "torch" }, + { name = "tqdm" }, + { name = "transformers" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f9/56/d2cb00765a6b15c994a7fccf20f9032f16e8193ca49147cb5155166ad744/sentence_transformers-5.6.0.tar.gz", hash = "sha256:0e7164d051e416c1853ade7c274ff52af3f9da0f4be7f0b83d734c27699e1057", size = 453194, upload-time = "2026-06-16T14:01:56.42Z" } wheels = [ @@ -6465,8 +6469,8 @@ name = "sentry-sdk" version = "2.60.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "certifi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "certifi" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/54/a2/2e6c090db384cc515069f4f85542bd5baf6786852073020ea73d4a76d3ea/sentry_sdk-2.60.0.tar.gz", hash = "sha256:0bd25e54e78ca02d0be512529fa644bbbf9e8470d7b26371294012d4ca93c978", size = 452946, upload-time = "2026-05-13T13:34:52.516Z" } wheels = [ @@ -6517,9 +6521,9 @@ name = "simpleqa-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/knowledge/simpleqa_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -6534,9 +6538,9 @@ name = "simpleqa-verified-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/knowledge/simpleqa_verified_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -6560,7 +6564,7 @@ name = "smart-open" version = "7.6.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "wrapt", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "wrapt" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c5/65/3ada667d32675399001bf022ad3d9f3989b57101351ebc71d6fbe2384634/smart_open-7.6.1.tar.gz", hash = "sha256:4347996e7ba21db7cd1e059632e0b30395407e4f6c660d2ddffc8f2a9ae5f990", size = 54754, upload-time = "2026-05-09T06:23:37.06Z" } wheels = [ @@ -6590,9 +6594,9 @@ name = "soundfile" version = "0.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cffi" }, + { name = "numpy" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d2/db/949331952a6fb1c5b12e9de80fd08747966c2039d1a61db4764fbd3981c2/soundfile-0.14.0.tar.gz", hash = "sha256:ba1c1a2d618bca5c406647c83b89f07cc8810fa506a50622a6993ba130c1de11", size = 47842, upload-time = "2026-06-06T08:58:47.869Z" } wheels = [ @@ -6615,25 +6619,25 @@ name = "spacy" version = "3.8.14" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "catalogue", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "confection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cymem", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "murmurhash", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "preshed", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "spacy-legacy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "spacy-loggers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "srsly", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "thinc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wasabi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "weasel", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "catalogue" }, + { name = "confection" }, + { name = "cymem" }, + { name = "jinja2" }, + { name = "murmurhash" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "preshed" }, + { name = "pydantic" }, + { name = "requests" }, + { name = "setuptools" }, + { name = "spacy-legacy" }, + { name = "spacy-loggers" }, + { name = "srsly" }, + { name = "thinc" }, + { name = "tqdm" }, + { name = "typer" }, + { name = "wasabi" }, + { name = "weasel" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/ff/e8/048d83b73b28686307bd9a60878a58de7b7b21b562ca4de8b5bd558031e9/spacy-3.8.14-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:daeb64b048f12c059997281aed53eb8776d26416dd313cf17ad6f63124b2b564", size = 32725099, upload-time = "2026-03-29T10:40:50.194Z" }, @@ -6665,7 +6669,7 @@ name = "srsly" version = "2.5.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "catalogue", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "catalogue" }, ] sdist = { url = "https://files.pythonhosted.org/packages/2b/db/f794f219a6c788b881252d2536a8c4a97d2bdaadc690391e1cb53d123d71/srsly-2.5.3.tar.gz", hash = "sha256:08f98dbecbff3a31466c4ae7c833131f59d3655a0ad8ac749e6e2c149e2b0680", size = 490881, upload-time = "2026-03-23T11:56:59.865Z" } wheels = [ @@ -6680,8 +6684,8 @@ name = "sse-starlette" version = "3.4.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "starlette", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "starlette" }, ] sdist = { url = "https://files.pythonhosted.org/packages/f7/2b/58abc2d1fd397e7dde08e947e05c884d8ef2f78d5e2588c17a12d42d6994/sse_starlette-3.4.4.tar.gz", hash = "sha256:07e0fa0460138baf25cdd5fb28683472c3995dc1642225191b3832d62526bcb0", size = 31819, upload-time = "2026-05-12T17:37:17.019Z" } wheels = [ @@ -6693,9 +6697,9 @@ name = "stack-data" version = "0.6.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "asttokens", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "executing", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pure-eval", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "asttokens" }, + { name = "executing" }, + { name = "pure-eval" }, ] sdist = { url = "https://files.pythonhosted.org/packages/28/e3/55dcc2cfbc3ca9c29519eb6884dd1415ecb53b0e934862d3559ddcb7e20b/stack_data-0.6.3.tar.gz", hash = "sha256:836a778de4fec4dcd1dcd89ed8abff8a221f58308462e1c4aa2a3cf30148f0b9", size = 44707, upload-time = "2023-09-30T13:58:05.479Z" } wheels = [ @@ -6707,8 +6711,8 @@ name = "starlette" version = "1.3.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/eb/e3/7c1dc7381d9f8ab7d854328ebfa884e62cb3f3d8549ddfd37c7814f42afa/starlette-1.3.1.tar.gz", hash = "sha256:05d0213193f2fbaae60e2ecb593b4add4262ad4e46536b54abe36f11a71724e0", size = 2703240, upload-time = "2026-06-12T09:23:11.602Z" } wheels = [ @@ -6720,10 +6724,10 @@ name = "storage3" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "deprecation", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", extra = ["http2"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "yarl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "deprecation" }, + { name = "httpx", extra = ["http2"] }, + { name = "pydantic" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/13/30/fee43d523d3f680a833a4aae5bf8094de0b9031b0c2bddb3e0bc6e829e1b/storage3-2.31.0.tar.gz", hash = "sha256:d2161e2ea650dc115a1787c30e09b118365589ac772f4dd8643e3a503ecfc667", size = 20348, upload-time = "2026-06-04T13:37:23.703Z" } wheels = [ @@ -6744,13 +6748,13 @@ name = "supabase" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "postgrest", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "realtime", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "storage3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "supabase-auth", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "supabase-functions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "yarl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx" }, + { name = "postgrest" }, + { name = "realtime" }, + { name = "storage3" }, + { name = "supabase-auth" }, + { name = "supabase-functions" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/fe/8e/54a2f950629689b1613434a61fc3bff5f92f84ba6b20213f5b2add05c1bb/supabase-2.31.0.tar.gz", hash = "sha256:3467b09d00482b9a0138235bdbde7a350426f93cf2a1342372eaddfc669f1206", size = 9805, upload-time = "2026-06-04T13:37:25.22Z" } wheels = [ @@ -6762,9 +6766,9 @@ name = "supabase-auth" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", extra = ["http2"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyjwt", extra = ["crypto"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx", extra = ["http2"] }, + { name = "pydantic" }, + { name = "pyjwt", extra = ["crypto"] }, ] sdist = { url = "https://files.pythonhosted.org/packages/61/8a/408689cf39820f0d46d2731d6747ff94dbefc87ae977b4b5c4066da5b070/supabase_auth-2.31.0.tar.gz", hash = "sha256:0945b33fa96239c76dc8eaf96d7d2c94991950d24b4cfe4a5c2da9aa5e909663", size = 39151, upload-time = "2026-06-04T13:37:27.375Z" } wheels = [ @@ -6776,9 +6780,9 @@ name = "supabase-functions" version = "2.31.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "httpx", extra = ["http2"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "strenum", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "yarl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httpx", extra = ["http2"] }, + { name = "strenum" }, + { name = "yarl" }, ] sdist = { url = "https://files.pythonhosted.org/packages/84/5d/61c2446ed26a57fa5543f9c270a731320911569202340d15341f72cdba7c/supabase_functions-2.31.0.tar.gz", hash = "sha256:4ad027b3ae3bd28b31233339f4db1da6965affd3546f655b421baf40cee2690f", size = 4683, upload-time = "2026-06-04T13:37:28.878Z" } wheels = [ @@ -6799,14 +6803,14 @@ name = "swe-rex" version = "1.4.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "bashlex", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pexpect", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-multipart", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "bashlex" }, + { name = "fastapi" }, + { name = "pexpect" }, + { name = "pydantic" }, + { name = "python-multipart" }, + { name = "requests" }, + { name = "rich" }, + { name = "uvicorn" }, ] sdist = { url = "https://files.pythonhosted.org/packages/94/86/a069f93ec866151a4d476d546e60220e66b3788878b6e248b2df3ab2c5f1/swe_rex-1.4.0.tar.gz", hash = "sha256:14f8a24c49a63f9e251340b1109ac75a4aacbaece410f8599209de9bfca843c0", size = 41755, upload-time = "2025-08-14T01:19:20.22Z" } wheels = [ @@ -6818,20 +6822,20 @@ name = "swebench" version = "4.1.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "beautifulsoup4", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "chardet", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "docker", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ghapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gitpython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "modal", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pre-commit", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "unidiff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "beautifulsoup4" }, + { name = "chardet" }, + { name = "datasets" }, + { name = "docker" }, + { name = "ghapi" }, + { name = "gitpython" }, + { name = "modal" }, + { name = "pre-commit" }, + { name = "python-dotenv" }, + { name = "requests" }, + { name = "rich" }, + { name = "tenacity" }, + { name = "tqdm" }, + { name = "unidiff" }, ] sdist = { url = "https://files.pythonhosted.org/packages/24/e1/c997299ad7bf088876d30398203aa1eed7dec897670dc1aa35b1d748ffcc/swebench-4.1.0.tar.gz", hash = "sha256:5aaa6a92c2db1aa64892d28a47483ca46a45a15cf1d2df673d7744f71811dc9a", size = 134341, upload-time = "2025-09-11T02:58:00.447Z" } wheels = [ @@ -6843,7 +6847,7 @@ name = "swebench-multilingual-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/swe/swebench_multilingual_v1" } dependencies = [ - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers", extra = ["harbor"] }, ] [package.metadata] @@ -6854,7 +6858,7 @@ name = "swebench-pro-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/swe/swebench_pro_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -6865,7 +6869,7 @@ name = "swebench-verified-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/swe/swebench_verified_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -6876,8 +6880,8 @@ name = "swelego-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/swelego_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6891,8 +6895,8 @@ name = "swerebench-v2-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/swerebench_v2_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -6911,10 +6915,10 @@ name = "swesmith-v1" version = "0.1.2" source = { editable = "deps/research-environments/environments/swe/swesmith_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "swebench", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "swesmith", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "swebench" }, + { name = "swesmith" }, + { name = "verifiers" }, ] [package.metadata] @@ -6939,7 +6943,7 @@ name = "sympy" version = "1.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mpmath", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "mpmath" }, ] sdist = { url = "https://files.pythonhosted.org/packages/83/d3/803453b36afefb7c2bb238361cd4ae6125a569b4db67cd9e79846ba2d68c/sympy-1.14.0.tar.gz", hash = "sha256:d3d3fe8df1e5a0b42f0e7bdf50541697dbe7d23746e894990c030e2b05e72517", size = 7793921, upload-time = "2025-04-27T18:05:01.611Z" } wheels = [ @@ -6951,7 +6955,7 @@ name = "synchronicity" version = "0.12.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/5d/1c/f51dc54bbd302991026a53f9790735540e0e9e1184e9d5939f02446aa5bc/synchronicity-0.12.5.tar.gz", hash = "sha256:94d96b1d85698e3056b96a793b8c0949af6584e4a7d877fabdeb5385efe230aa", size = 60745, upload-time = "2026-06-18T21:06:23.545Z" } wheels = [ @@ -6972,32 +6976,32 @@ name = "tau2" version = "0.2.1.dev0" source = { git = "https://github.com/sierra-research/tau2-bench.git?rev=337326e#337326e62d8e0ca74c353b004a9c5d748e0ba914" } dependencies = [ - { name = "addict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "deepdiff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "docstring-parser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fastapi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gymnasium", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "langfuse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "litellm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "loguru", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "matplotlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pandas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "plotly", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "psutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic-argparse", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pytest", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "redis", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ruff", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "scikit-learn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "seaborn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tabulate", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "toml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvicorn", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "watchdog", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "addict" }, + { name = "deepdiff" }, + { name = "docstring-parser" }, + { name = "fastapi" }, + { name = "fs" }, + { name = "gymnasium" }, + { name = "langfuse" }, + { name = "litellm" }, + { name = "loguru" }, + { name = "matplotlib" }, + { name = "pandas" }, + { name = "plotly" }, + { name = "psutil" }, + { name = "pydantic-argparse" }, + { name = "pytest" }, + { name = "pyyaml" }, + { name = "redis" }, + { name = "rich" }, + { name = "ruff" }, + { name = "scikit-learn" }, + { name = "seaborn" }, + { name = "tabulate" }, + { name = "tenacity" }, + { name = "toml" }, + { name = "uvicorn" }, + { name = "watchdog" }, ] [[package]] @@ -7005,8 +7009,8 @@ name = "tau2-bench-v1" version = "0.3.0" source = { editable = "deps/research-environments/environments/tool_use/tau2_bench_v1" } dependencies = [ - { name = "tau2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "tau2" }, + { name = "verifiers" }, ] [package.metadata] @@ -7030,16 +7034,16 @@ name = "tensorboard" version = "2.20.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "absl-py", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "grpcio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "markdown", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tensorboard-data-server", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "werkzeug", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "absl-py" }, + { name = "grpcio" }, + { name = "markdown" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pillow" }, + { name = "protobuf" }, + { name = "setuptools" }, + { name = "tensorboard-data-server" }, + { name = "werkzeug" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/9c/d9/a5db55f88f258ac669a92858b70a714bbbd5acd993820b41ec4a96a4d77f/tensorboard-2.20.0-py3-none-any.whl", hash = "sha256:9dc9f978cb84c0723acf9a345d96c184f0293d18f166bb8d59ee098e6cfaaba6", size = 5525680, upload-time = "2025-07-17T19:20:49.638Z" }, @@ -7059,7 +7063,7 @@ name = "terminal-bench-2-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/terminal/terminal_bench_2_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -7070,8 +7074,8 @@ name = "terminal-lego-v1" version = "0.1.1" source = { editable = "deps/research-environments/environments/terminal/terminal_lego_v1" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "verifiers" }, ] [package.metadata] @@ -7085,13 +7089,13 @@ name = "textarena" version = "0.7.4" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "chess", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nltk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "chess" }, + { name = "nltk" }, + { name = "openai" }, + { name = "python-dotenv" }, + { name = "requests" }, + { name = "rich" }, + { name = "websockets" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ba/04/4a3ca42093d0be2a9c377ae3335a6c6baac1d278ae932562ec69f339d172/textarena-0.7.4.tar.gz", hash = "sha256:28bb9170d7718f2ae05e4515bea82262422731e563fc7318a9e7983de0cadd4f", size = 954969, upload-time = "2025-10-16T14:41:55.981Z" } wheels = [ @@ -7103,12 +7107,12 @@ name = "textual" version = "8.2.7" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markdown-it-py", extra = ["linkify"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mdit-py-plugins", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pygments", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "markdown-it-py", extra = ["linkify"] }, + { name = "mdit-py-plugins" }, + { name = "platformdirs" }, + { name = "pygments" }, + { name = "rich" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/9b/7a/c519db0aba5024f86e71e9631810bfdd6866ed2c8695bd7fa34b90e7ef59/textual-8.2.7.tar.gz", hash = "sha256:658f568ff81e30ed43890c3e07520390e5cf1b4763822006e060656b0a88f105", size = 1859249, upload-time = "2026-05-19T10:52:49.531Z" } wheels = [ @@ -7120,8 +7124,8 @@ name = "textual-hires-canvas" version = "0.14.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textual", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "textual" }, ] sdist = { url = "https://files.pythonhosted.org/packages/20/f0/13f2a30ab7950cc3d5d5a2c893fbe3d40b4d129fd2cd30313260181578c4/textual_hires_canvas-0.14.0.tar.gz", hash = "sha256:0fa512492ddd2cd6c2a970a6beea58f5350f4cf25f40ad14ffd9fa86c6458769", size = 1251440, upload-time = "2026-01-10T22:16:56.708Z" } wheels = [ @@ -7133,9 +7137,9 @@ name = "textual-plot" version = "0.10.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textual", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textual-hires-canvas", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "textual" }, + { name = "textual-hires-canvas" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a0/c2/13f9f747e83cd0b740d1bf310e89a006316cfb5acb4e5a4136c12f96340b/textual_plot-0.10.1.tar.gz", hash = "sha256:503db96d849134293228419324eb15efbadf1f1927a2e0a229b54e7a7e5d5292", size = 2451096, upload-time = "2026-02-01T13:27:43.658Z" } wheels = [ @@ -7147,18 +7151,18 @@ name = "thinc" version = "8.3.13" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "blis", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "catalogue", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "confection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cymem", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "murmurhash", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "preshed", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "srsly", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wasabi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "blis" }, + { name = "catalogue" }, + { name = "confection" }, + { name = "cymem" }, + { name = "murmurhash" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "preshed" }, + { name = "pydantic" }, + { name = "setuptools" }, + { name = "srsly" }, + { name = "wasabi" }, ] sdist = { url = "https://files.pythonhosted.org/packages/13/46/76df95f2c327f9a9cef30c1523bf285627897097163584dcf5f77b2ebce2/thinc-8.3.13.tar.gz", hash = "sha256:68e658549fc1eb3ff92aed5147fcbb9c15d6e9cc0e623b4d0998d16522ffb4f9", size = 194640, upload-time = "2026-03-23T07:22:36.41Z" } wheels = [ @@ -7182,8 +7186,8 @@ name = "tiktoken" version = "0.13.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "regex", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "regex" }, + { name = "requests" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e4/e5/5f3cb2159769d0f4324c0e9e87f9de3c4b1cd45848a96b2eb3566ad5ca77/tiktoken-0.13.0.tar.gz", hash = "sha256:c9435714c3a84c2319499de9a300c0e604449dd0799ff246458b3bb6a7f433c1", size = 38986, upload-time = "2026-05-15T04:51:27.153Z" } wheels = [ @@ -7198,16 +7202,16 @@ name = "tilelang" version = "0.1.9" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cloudpickle", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "ml-dtypes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "psutil", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch-c-dlpack-ext", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "z3-solver", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "cloudpickle" }, + { name = "ml-dtypes" }, + { name = "numpy" }, + { name = "psutil" }, + { name = "torch" }, + { name = "torch-c-dlpack-ext" }, + { name = "tqdm" }, + { name = "typing-extensions" }, + { name = "z3-solver" }, ] sdist = { url = "https://files.pythonhosted.org/packages/56/70/5051f65821baa30a3d61fc48f8ba10c776490315e8c90f82559b92089756/tilelang-0.1.9.tar.gz", hash = "sha256:287f727c913bb648fcf6c1968809ba3390e55eeed257a5c6bb9a80bc05966af4", size = 93395292, upload-time = "2026-04-22T09:19:11.988Z" } wheels = [ @@ -7220,7 +7224,7 @@ name = "tmax-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/terminal/tmax_v1" } dependencies = [ - { name = "verifiers", extra = ["harbor"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers", extra = ["harbor"] }, ] [package.metadata] @@ -7231,7 +7235,7 @@ name = "tokenizers" version = "0.22.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, ] sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" } wheels = [ @@ -7246,10 +7250,10 @@ name = "tokenspeed-mla" version = "0.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cutlass-dsl", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenspeed-triton", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "nvidia-cutlass-dsl" }, + { name = "tokenspeed-triton" }, + { name = "torch" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/1e/65/81d7e9f14472bc4c6abb576c9b1edd8e40ab01832027c4e647bfe2890749/tokenspeed_mla-0.1.8-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:952209cf4b29a54e6b6e7e088be9d4a40f24792b06fdfa330de8077b9926a7d9", size = 752341, upload-time = "2026-06-24T03:36:28.619Z" }, @@ -7310,20 +7314,20 @@ name = "torch" version = "2.11.0+cu128" source = { registry = "https://download.pytorch.org/whl/cu128" } dependencies = [ - { name = "cuda-bindings", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fsspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jinja2", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "networkx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cudnn-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-cusparselt-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-nccl-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "nvidia-nvshmem-cu12", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setuptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sympy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "triton", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cuda-bindings" }, + { name = "cuda-toolkit", extra = ["cublas", "cudart", "cufft", "cufile", "cupti", "curand", "cusolver", "cusparse", "nvjitlink", "nvrtc", "nvtx"] }, + { name = "filelock" }, + { name = "fsspec" }, + { name = "jinja2" }, + { name = "networkx" }, + { name = "nvidia-cudnn-cu12" }, + { name = "nvidia-cusparselt-cu12" }, + { name = "nvidia-nccl-cu12" }, + { name = "nvidia-nvshmem-cu12" }, + { name = "setuptools" }, + { name = "sympy" }, + { name = "triton" }, + { name = "typing-extensions" }, ] wheels = [ { url = "https://download-r2.pytorch.org/whl/cu128/torch-2.11.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:9c8f38efee365cb9d334de8a83ce52fc7e5fc9e5a7b0853285efa1b69e00b0f2", upload-time = "2026-04-27T17:41:30Z" }, @@ -7335,7 +7339,7 @@ name = "torch-c-dlpack-ext" version = "0.1.5" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "torch" }, ] sdist = { url = "https://files.pythonhosted.org/packages/37/de/921b6491efce5c389a5ef9bbed3d2d6660005840dae488124173180859ab/torch_c_dlpack_ext-0.1.5.tar.gz", hash = "sha256:d06f0357d575d22a168cc77acb9020fc4bae30968ceb6718a055dcbe92bacabe", size = 12913, upload-time = "2026-01-12T11:25:08.484Z" } wheels = [ @@ -7418,9 +7422,9 @@ name = "torchdata" version = "0.11.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "requests" }, + { name = "torch" }, + { name = "urllib3" }, ] wheels = [ { url = "https://files.pythonhosted.org/packages/95/d4/af694ef718aedbe95a72760ab9ff7a6a7a44ace2d7f70c27bfeb67c5c503/torchdata-0.11.0-py3-none-any.whl", hash = "sha256:52b940fbbe0e00fb21cabddf528449d1bec5bfb0d0823b7487b15f951658ee33", size = 61968, upload-time = "2025-02-20T22:26:30.666Z" }, @@ -7431,13 +7435,13 @@ name = "torchtitan" version = "0.1.0" source = { git = "https://github.com/pytorch/torchtitan?rev=23e4dfc#23e4dfca5ca52587dbaf18f67bee8d73e875df5b" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "fsspec", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tensorboard", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torchdata", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tyro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "fsspec" }, + { name = "tensorboard" }, + { name = "tokenizers" }, + { name = "tomli" }, + { name = "torchdata" }, + { name = "tyro" }, ] [[package]] @@ -7445,9 +7449,9 @@ name = "torchvision" version = "0.26.0+cu128" source = { registry = "https://download.pytorch.org/whl/cu128" } dependencies = [ - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pillow", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "numpy" }, + { name = "pillow" }, + { name = "torch" }, ] wheels = [ { url = "https://download-r2.pytorch.org/whl/cu128/torchvision-0.26.0%2Bcu128-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:63e35234aed13b6edda37056f417b5c281249669db631e706811917af36b21d7", upload-time = "2026-04-09T23:21:35Z" }, @@ -7489,15 +7493,15 @@ name = "transformers" version = "5.6.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "huggingface-hub", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "regex", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "safetensors", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tokenizers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tqdm", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "huggingface-hub" }, + { name = "numpy" }, + { name = "packaging" }, + { name = "pyyaml" }, + { name = "regex" }, + { name = "safetensors" }, + { name = "tokenizers" }, + { name = "tqdm" }, + { name = "typer" }, ] sdist = { url = "https://files.pythonhosted.org/packages/a4/e9/c6c80a07690142a7d05444271f47b9f3c8aac7dea01d52e1137ee480ad78/transformers-5.6.2.tar.gz", hash = "sha256:e657134c3e5a6bc00a3c35f4e2674bb51adfcd89898495b788a18552bac2b91a", size = 8311867, upload-time = "2026-04-23T18:33:29.332Z" } wheels = [ @@ -7552,8 +7556,8 @@ name = "triviaqa-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/knowledge/triviaqa_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -7567,7 +7571,7 @@ name = "typeguard" version = "4.5.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/67/1c/dfba5c4633cafc4c701f237d2ba63b416805047fd6d96aab4cfc40969f98/typeguard-4.5.2.tar.gz", hash = "sha256:5a16dcac23502039299c97c8941651bc33d7ea8cc4b2f7d6bbb1b528f6eea423", size = 80240, upload-time = "2026-05-14T12:59:40.857Z" } wheels = [ @@ -7579,10 +7583,10 @@ name = "typer" version = "0.25.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "annotated-doc", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "shellingham", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "annotated-doc" }, + { name = "click" }, + { name = "rich" }, + { name = "shellingham" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e4/51/9aed62104cea109b820bbd6c14245af756112017d309da813ef107d42e7e/typer-0.25.1.tar.gz", hash = "sha256:9616eb8853a09ffeabab1698952f33c6f29ffdbceb4eaeecf571880e8d7664cc", size = 122276, upload-time = "2026-04-30T19:32:16.964Z" } wheels = [ @@ -7603,7 +7607,7 @@ name = "types-requests" version = "2.33.0.20260518" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "urllib3", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "urllib3" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e0/01/c5a19253fe1ac159159ddf9a3a07cec8bb5e486ec4d9002ad2821da0e5d2/types_requests-2.33.0.20260518.tar.gz", hash = "sha256:df7bd3bfe0ca8402dfb841e7d9be714bb5578203283d66d7dc4ef69343449a5e", size = 24752, upload-time = "2026-05-18T06:07:37.966Z" } wheels = [ @@ -7633,8 +7637,8 @@ name = "typing-inspect" version = "0.9.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "mypy-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "mypy-extensions" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/dc/74/1789779d91f1961fa9438e9a8710cdae6bd138c80d7303996933d117264a/typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78", size = 13825, upload-time = "2023-05-24T20:25:47.612Z" } wheels = [ @@ -7646,7 +7650,7 @@ name = "typing-inspection" version = "0.4.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" } wheels = [ @@ -7658,9 +7662,9 @@ name = "tyro" version = "1.0.13" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "docstring-parser", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typeguard", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "docstring-parser" }, + { name = "typeguard" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/24/d6/7126f9e7de139632134d59b5d1972e93c610ee2cb13829e8f4f48f6613cb/tyro-1.0.13.tar.gz", hash = "sha256:731a90c9836b77fffe7c3fa0477ef2d3b6fa91252ddc0bb4d32dadd4fcc143d4", size = 489479, upload-time = "2026-04-14T18:21:52.888Z" } wheels = [ @@ -7699,8 +7703,8 @@ name = "unscramble-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/reasoning/unscramble_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -7723,7 +7727,7 @@ name = "uuid-ctf-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/reasoning/uuid_ctf_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -7734,8 +7738,8 @@ name = "uvicorn" version = "0.48.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "h11", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "click" }, + { name = "h11" }, ] sdist = { url = "https://files.pythonhosted.org/packages/e6/bf/f6544ba992ddb9a6077343a576f9844f7f8f06ab819aefd00206e9255f18/uvicorn-0.48.0.tar.gz", hash = "sha256:a5504207195d08c2511bf9125ede5ac4a4b71725d519e758d01dcf0bc2d31c37", size = 91074, upload-time = "2026-05-24T12:08:41.925Z" } wheels = [ @@ -7744,12 +7748,12 @@ wheels = [ [package.optional-dependencies] standard = [ - { name = "httptools", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-dotenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvloop", marker = "(platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, - { name = "watchfiles", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "websockets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "httptools" }, + { name = "python-dotenv" }, + { name = "pyyaml" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy'" }, + { name = "watchfiles" }, + { name = "websockets" }, ] [[package]] @@ -7769,8 +7773,8 @@ name = "verbatim-copy-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/long_context/verbatim_copy_v1" } dependencies = [ - { name = "faker", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "faker" }, + { name = "verifiers" }, ] [package.metadata] @@ -7783,44 +7787,44 @@ requires-dist = [ name = "verifiers" source = { editable = "deps/verifiers" } dependencies = [ - { name = "aiohttp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "aiolimiter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "anthropic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gepa", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "loguru", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "math-verify", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "mcp", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "msgpack", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai-agents", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-pydantic-config", extra = ["toml"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-sandboxes", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "prime-tunnel", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyzmq", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "renderers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "rich", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "setproctitle", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tenacity", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "tomli-w", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "uvloop", marker = "(platform_machine == 'aarch64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux') or (platform_machine == 'x86_64' and platform_python_implementation != 'PyPy' and sys_platform == 'linux')" }, + { name = "aiohttp" }, + { name = "aiolimiter" }, + { name = "anthropic" }, + { name = "datasets" }, + { name = "gepa" }, + { name = "httpx" }, + { name = "loguru" }, + { name = "math-verify" }, + { name = "mcp" }, + { name = "msgpack" }, + { name = "numpy" }, + { name = "openai" }, + { name = "openai-agents" }, + { name = "prime-pydantic-config", extra = ["toml"] }, + { name = "prime-sandboxes" }, + { name = "prime-tunnel" }, + { name = "pydantic" }, + { name = "pyzmq" }, + { name = "renderers" }, + { name = "requests" }, + { name = "rich" }, + { name = "setproctitle" }, + { name = "tenacity" }, + { name = "tomli-w" }, + { name = "typing-extensions" }, + { name = "uvloop", marker = "platform_python_implementation != 'PyPy'" }, ] [package.optional-dependencies] harbor = [ - { name = "harbor", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "harbor" }, ] openenv = [ - { name = "openenv", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "openenv" }, ] ta = [ - { name = "nltk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "textarena", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "nltk" }, + { name = "textarena" }, ] [package.metadata] @@ -7901,10 +7905,10 @@ name = "virtualenv" version = "21.3.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "distlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "filelock", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "python-discovery", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "distlib" }, + { name = "filelock" }, + { name = "platformdirs" }, + { name = "python-discovery" }, ] sdist = { url = "https://files.pythonhosted.org/packages/15/ba/1f6e8c957e4932be060dcdc482d339c12e0216351478add3645cdaa53c05/virtualenv-21.3.3.tar.gz", hash = "sha256:f5bda277e553b1c2b3c1a8debfc30496e1288cc93ce6b7b71b3280047e317328", size = 7613784, upload-time = "2026-05-13T18:01:30.19Z" } wheels = [ @@ -7919,79 +7923,79 @@ resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", ] dependencies = [ - { name = "aiohttp", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "anthropic", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "apache-tvm-ffi", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "blake3", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "cachetools", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "cbor2", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "cloudpickle", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "compressed-tensors", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "depyf", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "einops", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "fastapi", extra = ["standard"], marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "fastsafetensors", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "filelock", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "flashinfer-python", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "humming-kernels", extra = ["cu12"], marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "ijson", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "jsonschema", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "lark", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "llguidance", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "lm-format-enforcer", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "mcp", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "mistral-common", extra = ["image"], marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "model-hosting-container-standards", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "msgspec", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "ninja", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "numba", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "numpy", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "nvidia-cudnn-frontend", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "nvidia-cutlass-dsl", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "nvtx", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "openai", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "openai-harmony", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "opencv-python-headless", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "opentelemetry-api", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "opentelemetry-exporter-otlp", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "opentelemetry-sdk", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "opentelemetry-semantic-conventions-ai", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "outlines-core", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "partial-json-parser", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pillow", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "prometheus-client", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "prometheus-fastapi-instrumentator", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "protobuf", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "psutil", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "py-cpuinfo", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pybase64", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pydantic", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pynvvideocodec", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "python-json-logger", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pyyaml", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "pyzmq", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "quack-kernels", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "regex", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "requests", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "safetensors", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "sentencepiece", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "setproctitle", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "setuptools", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "six", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "starlette", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "tiktoken", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "tilelang", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "tokenizers", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "tokenspeed-mla", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torch", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torchaudio", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torchcodec", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "torchvision", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "tqdm", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "transformers", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "watchfiles", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "xgrammar", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, + { name = "aiohttp" }, + { name = "anthropic" }, + { name = "apache-tvm-ffi" }, + { name = "blake3" }, + { name = "cachetools" }, + { name = "cbor2" }, + { name = "cloudpickle" }, + { name = "compressed-tensors" }, + { name = "depyf" }, + { name = "einops" }, + { name = "fastapi", extra = ["standard"] }, + { name = "fastsafetensors" }, + { name = "filelock" }, + { name = "flashinfer-python" }, + { name = "humming-kernels", extra = ["cu12"] }, + { name = "ijson" }, + { name = "jsonschema" }, + { name = "lark" }, + { name = "llguidance" }, + { name = "lm-format-enforcer" }, + { name = "mcp" }, + { name = "mistral-common", extra = ["image"] }, + { name = "model-hosting-container-standards" }, + { name = "msgspec" }, + { name = "ninja" }, + { name = "numba" }, + { name = "numpy" }, + { name = "nvidia-cudnn-frontend" }, + { name = "nvidia-cutlass-dsl" }, + { name = "nvtx" }, + { name = "openai" }, + { name = "openai-harmony" }, + { name = "opencv-python-headless" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp" }, + { name = "opentelemetry-sdk" }, + { name = "opentelemetry-semantic-conventions-ai" }, + { name = "outlines-core" }, + { name = "partial-json-parser" }, + { name = "pillow" }, + { name = "prometheus-client" }, + { name = "prometheus-fastapi-instrumentator" }, + { name = "protobuf" }, + { name = "psutil" }, + { name = "py-cpuinfo" }, + { name = "pybase64" }, + { name = "pydantic" }, + { name = "pynvvideocodec" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "pyzmq" }, + { name = "quack-kernels" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "sentencepiece" }, + { name = "setproctitle" }, + { name = "setuptools" }, + { name = "six" }, + { name = "starlette" }, + { name = "tiktoken" }, + { name = "tilelang" }, + { name = "tokenizers" }, + { name = "tokenspeed-mla" }, + { name = "torch" }, + { name = "torchaudio" }, + { name = "torchcodec" }, + { name = "torchvision" }, + { name = "tqdm" }, + { name = "transformers" }, + { name = "typing-extensions" }, + { name = "watchfiles" }, + { name = "xgrammar" }, ] wheels = [ { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:a21f3a78adffce8f3e88b08ad1145ff5d7d6e0618c652db3e0b914c700cd9b64" }, @@ -8107,79 +8111,79 @@ resolution-markers = [ "platform_machine == 'x86_64' and sys_platform == 'linux'", ] dependencies = [ - { name = "aiohttp", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "anthropic", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "apache-tvm-ffi", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "blake3", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "cachetools", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "cbor2", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "cloudpickle", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "compressed-tensors", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "depyf", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "einops", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "fastapi", extra = ["standard"], marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "fastsafetensors", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "filelock", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "flashinfer-python", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "humming-kernels", extra = ["cu12"], marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "ijson", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "jsonschema", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "lark", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "llguidance", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "lm-format-enforcer", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "mcp", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "mistral-common", extra = ["image"], marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "model-hosting-container-standards", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "msgspec", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "ninja", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "numba", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "numpy", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "nvidia-cudnn-frontend", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "nvidia-cutlass-dsl", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "nvtx", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "openai", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "openai-harmony", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "opencv-python-headless", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "opentelemetry-api", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "opentelemetry-exporter-otlp", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "opentelemetry-sdk", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "opentelemetry-semantic-conventions-ai", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "outlines-core", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "partial-json-parser", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pillow", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "prometheus-client", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "prometheus-fastapi-instrumentator", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "protobuf", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "psutil", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "py-cpuinfo", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pybase64", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pydantic", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pynvvideocodec", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "python-json-logger", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pyyaml", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "pyzmq", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "quack-kernels", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "regex", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "requests", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "safetensors", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "sentencepiece", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "setproctitle", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "setuptools", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "six", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "starlette", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "tiktoken", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "tilelang", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "tokenizers", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "tokenspeed-mla", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torch", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torchaudio", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torchcodec", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "torchvision", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "tqdm", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "transformers", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "watchfiles", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "xgrammar", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "aiohttp" }, + { name = "anthropic" }, + { name = "apache-tvm-ffi" }, + { name = "blake3" }, + { name = "cachetools" }, + { name = "cbor2" }, + { name = "cloudpickle" }, + { name = "compressed-tensors" }, + { name = "depyf" }, + { name = "einops" }, + { name = "fastapi", extra = ["standard"] }, + { name = "fastsafetensors" }, + { name = "filelock" }, + { name = "flashinfer-python" }, + { name = "humming-kernels", extra = ["cu12"] }, + { name = "ijson" }, + { name = "jsonschema" }, + { name = "lark" }, + { name = "llguidance" }, + { name = "lm-format-enforcer" }, + { name = "mcp" }, + { name = "mistral-common", extra = ["image"] }, + { name = "model-hosting-container-standards" }, + { name = "msgspec" }, + { name = "ninja" }, + { name = "numba" }, + { name = "numpy" }, + { name = "nvidia-cudnn-frontend" }, + { name = "nvidia-cutlass-dsl" }, + { name = "nvtx" }, + { name = "openai" }, + { name = "openai-harmony" }, + { name = "opencv-python-headless" }, + { name = "opentelemetry-api" }, + { name = "opentelemetry-exporter-otlp" }, + { name = "opentelemetry-sdk" }, + { name = "opentelemetry-semantic-conventions-ai" }, + { name = "outlines-core" }, + { name = "partial-json-parser" }, + { name = "pillow" }, + { name = "prometheus-client" }, + { name = "prometheus-fastapi-instrumentator" }, + { name = "protobuf" }, + { name = "psutil" }, + { name = "py-cpuinfo" }, + { name = "pybase64" }, + { name = "pydantic" }, + { name = "pynvvideocodec" }, + { name = "python-json-logger" }, + { name = "pyyaml" }, + { name = "pyzmq" }, + { name = "quack-kernels" }, + { name = "regex" }, + { name = "requests" }, + { name = "safetensors" }, + { name = "sentencepiece" }, + { name = "setproctitle" }, + { name = "setuptools" }, + { name = "six" }, + { name = "starlette" }, + { name = "tiktoken" }, + { name = "tilelang" }, + { name = "tokenizers" }, + { name = "tokenspeed-mla" }, + { name = "torch" }, + { name = "torchaudio" }, + { name = "torchcodec" }, + { name = "torchvision" }, + { name = "tqdm" }, + { name = "transformers" }, + { name = "typing-extensions" }, + { name = "watchfiles" }, + { name = "xgrammar" }, ] wheels = [ { url = "https://github.com/vllm-project/vllm/releases/download/v0.26.0/vllm-0.26.0+cu129-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6ce4ca30616f0a35810391015622b197a7b8b267ed27f8716f0789db79ff578b" }, @@ -8295,12 +8299,12 @@ resolution-markers = [ "platform_machine == 'aarch64' and sys_platform == 'linux'", ] dependencies = [ - { name = "aiohttp", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "fastapi", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "orjson", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "requests", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "setproctitle", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, - { name = "uvicorn", marker = "platform_machine == 'aarch64' and sys_platform == 'linux'" }, + { name = "aiohttp" }, + { name = "fastapi" }, + { name = "orjson" }, + { name = "requests" }, + { name = "setproctitle" }, + { name = "uvicorn" }, ] wheels = [ { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:ab8d0da61faa588fd5a7ed947bd58ddb31f5836cf55518bdd0122cfbc83989f4" }, @@ -8328,12 +8332,12 @@ resolution-markers = [ "platform_machine == 'x86_64' and sys_platform == 'linux'", ] dependencies = [ - { name = "aiohttp", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "fastapi", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "orjson", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "requests", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "setproctitle", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "uvicorn", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, + { name = "aiohttp" }, + { name = "fastapi" }, + { name = "orjson" }, + { name = "requests" }, + { name = "setproctitle" }, + { name = "uvicorn" }, ] wheels = [ { url = "https://github.com/PrimeIntellect-ai/router/releases/download/v0.1.26/vllm_router-0.1.26-cp38-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:db0c9410a4c130da8ffeea22f569faca7c85c58c5e183be1ebf758076361a6ec" }, @@ -8367,16 +8371,16 @@ name = "wandb" version = "0.27.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "click", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "gitpython", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "platformdirs", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "protobuf", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pyyaml", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "requests", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sentry-sdk", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "click" }, + { name = "gitpython" }, + { name = "packaging" }, + { name = "platformdirs" }, + { name = "protobuf" }, + { name = "pydantic" }, + { name = "pyyaml" }, + { name = "requests" }, + { name = "sentry-sdk" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/8e/31/fe53d06b75ef0a7f2f0ee5931a89f7aedc27d233840b1839616860fed256/wandb-0.27.0.tar.gz", hash = "sha256:579e75300173059f9334e1f513a79ef15f6d9ea5c74e20d695633648cdd02031", size = 41090732, upload-time = "2026-05-14T03:44:08.894Z" } wheels = [ @@ -8391,8 +8395,8 @@ name = "wandb-workspaces" version = "0.4.3" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wandb", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "pydantic" }, + { name = "wandb" }, ] sdist = { url = "https://files.pythonhosted.org/packages/44/90/749e3af75f1bc2685711176f8f0fe6dae38d5b979e4dc160c30cd4373597/wandb_workspaces-0.4.3.tar.gz", hash = "sha256:2c551bc35cadda14ff0c7c3ac1d7bbbb1c95b8f0dbc662ec2c58f3d3d832f854", size = 234226, upload-time = "2026-06-10T22:27:17.22Z" } wheels = [ @@ -8423,7 +8427,7 @@ name = "watchfiles" version = "1.2.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, ] sdist = { url = "https://files.pythonhosted.org/packages/cd/41/5e1a4bb12aac5f1493fa1bdc11154eca3b258ca4eba65d39c473fe19d8e9/watchfiles-1.2.0.tar.gz", hash = "sha256:c995fba777f1ea992f090f9236e9284cf7a5d1a0130dd5a3d82c598cacd76838", size = 108252, upload-time = "2026-05-18T04:32:04.251Z" } wheels = [ @@ -8447,15 +8451,15 @@ name = "weasel" version = "1.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "cloudpathlib", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "confection", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "packaging", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "smart-open", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "srsly", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typer", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "wasabi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "cloudpathlib" }, + { name = "confection" }, + { name = "httpx" }, + { name = "packaging" }, + { name = "pydantic" }, + { name = "smart-open" }, + { name = "srsly" }, + { name = "typer" }, + { name = "wasabi" }, ] sdist = { url = "https://files.pythonhosted.org/packages/ce/e5/e272bb9a045105a1fdf4b798d8086f5932a178f4d738f17a74f5c9e0ae9a/weasel-1.0.0.tar.gz", hash = "sha256:7b129b44c90cc543b760532974ca1e4eb30dad2aa2026f57bdce66354ae610fc", size = 38682, upload-time = "2026-03-20T08:10:25.266Z" } wheels = [ @@ -8489,7 +8493,7 @@ name = "werkzeug" version = "3.1.8" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "markupsafe", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "markupsafe" }, ] sdist = { url = "https://files.pythonhosted.org/packages/dd/b2/381be8cfdee792dd117872481b6e378f85c957dd7c5bca38897b08f765fd/werkzeug-3.1.8.tar.gz", hash = "sha256:9bad61a4268dac112f1c5cd4630a56ede601b6ed420300677a869083d70a4c44", size = 875852, upload-time = "2026-04-02T18:49:14.268Z" } wheels = [ @@ -8501,9 +8505,9 @@ name = "wideseek-v1" version = "0.2.0" source = { editable = "deps/research-environments/environments/search/wideseek_v1" } dependencies = [ - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "openai", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "datasets" }, + { name = "openai" }, + { name = "verifiers" }, ] [package.metadata] @@ -8527,9 +8531,9 @@ name = "wiki-search-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/wiki_search_v1" } dependencies = [ - { name = "chromadb", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "datasets", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "chromadb" }, + { name = "datasets" }, + { name = "verifiers" }, ] [package.metadata] @@ -8544,7 +8548,7 @@ name = "wikispeedia-v1" version = "0.1.0" source = { editable = "deps/research-environments/environments/reasoning/wikispeedia_v1" } dependencies = [ - { name = "verifiers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers" }, ] [package.metadata] @@ -8555,7 +8559,7 @@ name = "wordle-v1" version = "0.1.0" source = { editable = "deps/verifiers/environments/wordle_v1" } dependencies = [ - { name = "verifiers", extra = ["ta"], marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "verifiers", extra = ["ta"] }, ] [package.metadata] @@ -8579,13 +8583,13 @@ name = "writer-sdk" version = "3.0.0" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "anyio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "distro", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "httpx", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "jiter", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "sniffio", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "anyio" }, + { name = "distro" }, + { name = "httpx" }, + { name = "jiter" }, + { name = "pydantic" }, + { name = "sniffio" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/c1/d7/35511e37c87025ce3928d7c98a661680140076407c813d4020e746a77214/writer_sdk-3.0.0.tar.gz", hash = "sha256:99815ecff4d112a791280ca9d5c8d4884fa2d13d8e4c454af163653f0251aed2", size = 305155, upload-time = "2026-06-02T18:27:41.954Z" } wheels = [ @@ -8597,13 +8601,13 @@ name = "xgrammar" version = "0.2.1" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "apache-tvm-ffi", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "numpy", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "pydantic", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "torch", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "transformers", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "triton", marker = "platform_machine == 'x86_64' and sys_platform == 'linux'" }, - { name = "typing-extensions", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "apache-tvm-ffi" }, + { name = "numpy" }, + { name = "pydantic" }, + { name = "torch" }, + { name = "transformers" }, + { name = "triton", marker = "platform_machine == 'x86_64'" }, + { name = "typing-extensions" }, ] sdist = { url = "https://files.pythonhosted.org/packages/d8/ea/6394caddd078d33772070eefaaf77cb0a826a3047b908b688dece7d040b5/xgrammar-0.2.1.tar.gz", hash = "sha256:4c48c251b75d211e9ffa7f4f4ac8b5b0164f89fd5f0d1883ad7ff4554922030d", size = 2427065, upload-time = "2026-05-17T21:39:26.576Z" } wheels = [ @@ -8628,9 +8632,9 @@ name = "yarl" version = "1.24.2" source = { registry = "https://pypi.org/simple" } dependencies = [ - { name = "idna", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "multidict", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, - { name = "propcache", marker = "(platform_machine == 'aarch64' and sys_platform == 'linux') or (platform_machine == 'x86_64' and sys_platform == 'linux')" }, + { name = "idna" }, + { name = "multidict" }, + { name = "propcache" }, ] sdist = { url = "https://files.pythonhosted.org/packages/79/12/1e8f37460ea0f7eb59c221fdaf0ed75e7ac43e97f8093b9c6f411df50a78/yarl-1.24.2.tar.gz", hash = "sha256:9ac374123c6fd7abf64d1fec93962b0bd4ee2c19751755a762a72dd96c0378f8", size = 210798, upload-time = "2026-05-19T21:31:05.599Z" } wheels = [